package importer;

import com.evolute.utils.error.ErrorLogger;
import db.entidades.Area;
import db.entidades.Medida;
import db.entidades.PlanoActuacao;
import db.entidades.PostoTrabalho;
import db.entidades.Risco;
import db.entidades.Utilizador;
import db.entidades.Valor;
import db.providers.EvoBaseProvider;
import db.providers.UtilizadoresDataProvider;
import java.io.File;
import java.io.FileInputStream;
import utils.Global;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Properties;
import mail.Mail;
import mail.MailNextPhase;
import mail.MailNextPhase.SIPRP_TO_RESPONSAVEL_SEGURANCA;
import shst.companydataloaders.SIPRPPropertiesLoader;
import shst.data.outer.HsRelatorioData;
import shst.data.provider.PlanoActuacaoDataProvider;
import utils.PlanosActuacaoLogger;


public class PlanosActuacaoImporter
{

	public static void main( final String[] args )
	{
		try
		{
			System.out.println( "\nInit: PA logger ..." );
			PlanosActuacaoLogger.init();

			System.out.println( "\nInit: properties ..." );
			readProperties( args );

			System.out.println( "\nInit: db ..." );
			EvoBaseProvider.getInstance();

			System.out.println( "\nInit: A importar Planos de Actua\u00E7\u00E3o ..." );
			PlanosActuacaoImporter.getInstace().init();
		}
		catch ( Exception e )
		{
			e.printStackTrace( System.out );
		}
	}

	private static void readProperties( String[] args ) throws Exception
	{
		if ( args != null && args.length > 0 )
		{
			String filepath = args[ 0 ];
			File f = new File( filepath );
			if ( f.isFile() )
			{
				Properties props = new Properties();
				props.load( new FileInputStream( f ) );
				Iterator< Object > it = props.keySet().iterator();
				while ( it.hasNext() )
				{
					Object key = it.next();
					Object value = props.get( key );
					System.setProperty( ( String ) key, ( String ) value );
				}
			}
			else
			{
				throw new IllegalArgumentException( "USAGE: java PlanosActuacaoImporter <app.properties path>" );
			}
		}
		else
		{
//			throw new IllegalArgumentException( "USAGE: java PlanosActuacaoImporter <app.properties path>" );
			System.out.println( "\tNo properties file given. Trying to use project properties ..." );
			readProjectProperties();
		}
	}

	private static void readProjectProperties() throws Exception
	{
		SIPRPPropertiesLoader.forceEncryptedPropertiesFile = false;
		SIPRPPropertiesLoader.getInstance().load();
	}



    private void debug( String debugMessage )
    {
        System.out.println( debugMessage );
    }


	private static PlanosActuacaoImporter INSTANCE = null;

	private PlanosActuacaoImporter()
	{

	}

	public static synchronized PlanosActuacaoImporter getInstace()
	{
		if ( INSTANCE == null )
		{
			INSTANCE = new PlanosActuacaoImporter();
		}
		return INSTANCE;
	}

	public void init()
	{
		initRelatorios( null, null );
	}
	
//    private List< PlanoActuacao > planosList;
//    private List< Date > planosOnlineList;
    
//    public PlanosActuacao( Utilizador u )
//	{
//        try
//        {
//            //rdp = new RelatoriosDataProvider();
//            Integer estabelecimentoId = null;
//            if(u.getTipo().intValue() != Global.TECNICO_HS && u.getTipo().intValue() != Global.DIRECTOR_SIPRP)
//            {
//                estabelecimentoId = u.getEstabelecimento_id();
//            }
//            List< Date > planosOnlineList = getPlanosOnline( estabelecimentoId );
//            System.out.println("PLANOS ONLINE LIST : " + planosOnlineList.size());
//            initRelatorios( planosOnlineList, estabelecimentoId );
//        }
//        catch ( Exception ex )
//        {
//            ErrorLogger.logException( ex );
//        }
//    }
    
//    private List< Date > getPlanosOnline( Integer estabelecimentoId )
//    {
//        List< Date > list = null;
//        try
//        {
//        	if ( estabelecimentoId != null )
//            {
//				CreatePlanosDataProvider cpdp = CreatePlanosDataProvider.getInstance();
//        		list = cpdp.getPlanosOnline( estabelecimentoId );
//            }
//        }
//        catch ( Exception ex )
//        {
//            ErrorLogger.logException( ex );
//        }
//        return list == null ? new LinkedList< Date >() : list;
//    }
    
    private void initRelatorios( List< Date > datesList, Integer fromEstabelecimentoID )
    {
        debug("\ninitRelatorios( " + datesList + ", " + fromEstabelecimentoID + " ) : ");
		try
		{
			PlanosActuacaoImporterProvider provider = PlanosActuacaoImporterProvider.getInstance();
			PlanoActuacaoDataProvider planosProvider = PlanoActuacaoDataProvider.getProvider();

			if ( fromEstabelecimentoID == null )
			{
				debug( "\n\tA adicionar novos planos ..." );

				List< Integer > estabelecimentos = provider.getEstabelecimentosWithPlanos();
				putPlanosOnline( planosProvider.getRelatoriosNotIn( estabelecimentos ) );

				estabelecimentos = provider.getEstabelecimentosWithPlanos();
				debug("\n\tA adicionar planos a estabelecimentos anteriores");
				for ( Integer estabelecimentoID : estabelecimentos )
				{
					try
					{
						debug( "\n\t\tA importar relatorio para o estabelecimento: " + estabelecimentoID );
						List< Date > datas = provider.getPlanosOnline( estabelecimentoID );
						if ( datas.isEmpty() )
						{
							debug("\n\t\t\tNenhuma data de relatorio para o estabelecimento: " + estabelecimentoID);
						}
						else
						{
							List< HsRelatorioData > relatorios = planosProvider.getRelatoriosNotIn( datas, estabelecimentoID );
							if ( relatorios.isEmpty() )
							{
								debug("\n\t\t\tNenhum relatorio novo para o estabelecimento: " + estabelecimentoID);
							}
							else
							{
								putPlanosOnline( relatorios );
							}
						}
					}
					catch ( Exception e )
					{
						ErrorLogger.logException( e );
					}
				}
			}
			else
			{
				putPlanosOnline(planosProvider.getRelatoriosNotIn(datesList, fromEstabelecimentoID));
			}
		}
		catch ( Exception e )
		{
			ErrorLogger.logException( e );
		}
    }
    
    private void putPlanosOnline( List< HsRelatorioData > listRelatorios )
    {
        debug("\n\t\t\tputPlanosOnline (" + listRelatorios == null ? "[null]" : "" + listRelatorios.size());
        for ( HsRelatorioData relatorio : listRelatorios )
        {
            debug("\t\t\t\tRelatorioID : " + relatorio.getId());
            try
            {
                PlanoActuacao p = createPlano( relatorio );
                if ( p != null )
                {
                    enviarMail( p );
                }
            }
            catch ( Exception ex )
            {
                debug("\nERRO NA CRIACAO DOS PLANOS : " + ex.getMessage());
                ErrorLogger.logException( ex );
            }
        }
    }
    
    private PlanoActuacao createPlano( HsRelatorioData relatorio ) throws Exception
    {
        debug("\n\t\t\t\t\tCREATE PLANO - RELATORIO ID : " + relatorio.getId());

		PlanosActuacaoImporterProvider provider = PlanosActuacaoImporterProvider.getInstance();
		
        PlanoActuacao p = new PlanoActuacao();
		p.setData_visita( relatorio.toMarcacao_id().getData() );

		if ( relatorio.toMarcacao_id().toTecnico_hst() != null )
        {
			p.setTecnico_hs_id( relatorio.toMarcacao_id().toTecnico_hst().getId() );
			p.setTecnico_hs_nome( relatorio.toMarcacao_id().toTecnico_hst().getNome() );
        }

		if ( relatorio.toMarcacao_id().toTecnico_superior_hst() != null )
		{
			p.setTecnico_superior_hs_id( relatorio.toMarcacao_id().toTecnico_superior_hst().getId() );
			p.setTecnico_superior_hs_nome( relatorio.toMarcacao_id().toTecnico_superior_hst().getNome() );
		}

        p.setFase( new Integer( Global.FASE_SEGURANCA_PREENCHIMENTO ) );

		p.setEstabelecimento_id( relatorio.toMarcacao_id().toEstabelecimento_id().getId() );
		p.setEmpresa_id( relatorio.toMarcacao_id().toEstabelecimento_id().toEmpresa_id().getId() );
        try
        {
            p.setNome_empresa( utils.Utils.unicodeToHTML( provider.getEmpresaNome( p.getEmpresa_id() ) ) );
        }
        catch ( Exception ex )
        {
            ErrorLogger.logException( ex );
        }
		p.setNome_estabelecimento( relatorio.toMarcacao_id().toEstabelecimento_id().getNome() );
        p.setData_relatorio( relatorio.getData() );
		p.setData_disponibilizacao( relatorio.getIs_submetido() );
		p.setHs_relatorio_id( relatorio.getId() );
		
        p = provider.getFullPlano( p, relatorio.getId() );
        if ( p.getAreas() != null )
        {
            if ( p.getAreas().size() > 0 )
            {
                p.setId( provider.createPlano( p ) );
                debug("\n\t\t\t\t\t\tCREATE PLANO - PLANO ID : " + p.getId());
                if ( p.getAreas() != null )
                {
                    createAreas( p.getId(), p.getAreas() );
                }
            }
            else
            {
                p = null;
            }
        }
        else
        {
            p = null;
        }

        return p;
    }
    
    private void createAreas( Integer plano_id, List< Area > areas ) throws Exception
    {
		PlanosActuacaoImporterProvider provider = PlanosActuacaoImporterProvider.getInstance();
        for ( Area a : areas )
        {
            a.setPlano_id( plano_id );
            a.setId( provider.createArea( a ) );
            System.out.println( "AREA =: " + a.getId().toString() );
            if ( a.getRiscos() != null )
            {
                System.out.println( "AREA RISCOS: " + a.getRiscos().size() );
                createRiscos( a.getId(), a.getRiscos() );
            }
        }
    }
	
    private void createRiscos( Integer area_id, List< Risco > riscos ) throws Exception
    {
		PlanosActuacaoImporterProvider provider = PlanosActuacaoImporterProvider.getInstance();
        for ( Risco r : riscos )
        {
            r.setArea_id( area_id );
            System.out.println( "CREATE RISCO: " );
            if ( r.getValores() != null )
            {
                for ( Valor v : r.getValores() )
                {
                    r.setValorQuantitativo( v.getValorQuantitativo() );
                    r.setValorQualitativoID( v.getValorQualitativoID() );
                    r.setId( provider.createRisco( r ) );
                }
            }
            if ( r.getMedidas() != null )
            {
                createMedidas( r.getId(), r.getMedidas() );
            }
        }
    }
    
    private void createMedidas( Integer risco_id, List< Medida > medidas ) throws Exception
    {
		PlanosActuacaoImporterProvider provider = PlanosActuacaoImporterProvider.getInstance();
        for ( Medida m : medidas )
        {
            m.setRisco_id( risco_id );
            m.setId( provider.createMedida( m ) );
            if ( m.getPostos() != null )
            {
                createPostos( m.getId(), m.getPostos() );
            }
        }
    }
    
    private void createPostos( Integer medida_id, List< PostoTrabalho > postos ) throws Exception
    {
		PlanosActuacaoImporterProvider provider = PlanosActuacaoImporterProvider.getInstance();
        for ( PostoTrabalho p : postos )
        {
            p.setMedida_id( medida_id );
            provider.createPostoTrabalho( p );
        }
    }


    private void enviarMail( PlanoActuacao p )
    {
        MailNextPhase nextPhase = null;
        
        int fase = p.getFase().intValue();
        int tipo_utilizador = 0;
        switch ( fase )
        {
            case Global.FASE_SEGURANCA_PREENCHIMENTO : // SIPRP para RS
                tipo_utilizador = Global.RESPONSAVEL_SEGURANCA;
				nextPhase = new SIPRP_TO_RESPONSAVEL_SEGURANCA( p );
                break;
        }

		if ( nextPhase != null )
		{
			String responsavel_loja = "n";
			if ( tipo_utilizador == Global.RESPONSAVEL_SEGURANCA )
			{
				responsavel_loja = "y";
			}
			try
			{
				Mail mail = new Mail();

				UtilizadoresDataProvider udp = UtilizadoresDataProvider.getInstance();
				List< Utilizador > list = udp.getUtilizadoresListByTipo( tipo_utilizador, responsavel_loja, p.getEstabelecimento_id() );
				ListIterator iter = list.listIterator();
				while ( iter.hasNext() )
				{
					Utilizador u = ( Utilizador ) iter.next();
					System.out.println( "\t\tUSER MAIL NEXT FASE : " + u.getLogin() + " ; " + u.getEmail() );
					try
					{
						mail.send( u.getEmail(), Mail.ENDERECO_ENVIO, nextPhase );
						System.out.println( "\t\t\tEMAIL ENVIADO !!" );
					}
					catch ( Exception ex1 )
					{
						ErrorLogger.logException( ex1 );
						System.out.println("\t\t\tMAIL ERROR : " + ex1.getMessage());
					}
				}
			}
			catch ( Exception ex )
			{
				ErrorLogger.logException( ex );
			}
		}
    }    
}