package com.megatim.apifdxweb.service.impl.scheduler;

import com.megatim.apifdxweb.core.ifaces.tmp.TokenTmpManager;
import com.megatim.apifdxweb.core.ifaces.tmp.TypeFichierDataTmpManager;
import com.megatim.apifdxweb.model.tmp.StatutTmp;
import com.megatim.apifdxweb.model.tmp.TokenTmp;
import com.megatim.apifdxweb.model.tmp.TypeFichierDataTmp;
import com.megatim.apifdxweb.service.ifaces.scheduler.TypeFichierDataTmpJob;
import com.megatim.apifdxweb.tools.AppContext;
import com.megatim.fdxcommons.core.ifaces.helper.DataInMemoryHandler;
import com.megatim.fdxcommons.model.dataproduction.DataProduction;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.enterprise.context.Dependent;
import javax.inject.Inject;
import javax.transaction.Transactional;
import com.megatim.fdxcommons.model.dataproduction.DataProductionSource;
import com.megatim.fdxcommons.tools.database.connection.DBConnection;
import com.megatim.fdxcommons.tools.database.tables.FdxApiTable;
import java.sql.Connection;
import java.sql.SQLException;
import java.time.LocalDateTime;
import javax.annotation.Resource;
import javax.naming.NamingException;
import javax.sql.DataSource;

/**
 *
 * @author ASUS
 */
@Dependent
public class TypeFichierDataTmpJobImpl implements TypeFichierDataTmpJob {

    @Inject
    private TokenTmpManager tokenTmpManager;

    @Inject
    private TypeFichierDataTmpManager dataTmpManager;

    @Inject
    private DataInMemoryHandler dataInMemoryHandler;

    @Resource(lookup = AppContext.JNDI_NAME)
    private DataSource dataSource;

    @Override
    public void mergeData() {
        List<TokenTmp> tokens = tokenTmpManager.getByStatutTmp(StatutTmp.ACHEVE);
        tokens.stream().forEach(t -> {
            try {
                List<LinkedHashMap<String, Object>> data = dataTmpManager.getByStructuredLines(t.getToken(), t.getCodeTypeFichier());
                updateDatabase(data, t);
            } catch (Exception ex) {
                Logger.getLogger(TypeFichierDataTmpJobImpl.class.getName()).log(Level.SEVERE, ex.getMessage(), ex);
            }
        });
    }

    @Override
    @Transactional
    public void deleteExpiredTokens() {
        List<TokenTmp> tokenExpired = tokenTmpManager.getExpiredToken();

        for (TokenTmp t : tokenExpired) {
            List<TypeFichierDataTmp> data = dataTmpManager.getByToken(t.getToken());
            for (TypeFichierDataTmp d : data) {
                dataTmpManager.delete(d);
            }
            tokenTmpManager.delete(t);
        }
    }

    @Transactional
    private void updateDatabase(List<LinkedHashMap<String, Object>> data, TokenTmp tokenTmp) throws Exception {
        insert(tokenTmp.getCodeTypeFichier(),
                dataInMemoryHandler.getDataInMemory().getReferentielEnCours().getVersion(),
                data,
                tokenTmp.getCodeParticipant());

        deleteTokenTmp(tokenTmp);
    }

    private void insert(String codeTypeFichier, String referentielVersion, List<LinkedHashMap<String, Object>> data, String connectedParticipant) throws SQLException, NamingException, Exception {
        DataProduction dataProduction = newDataProduction(codeTypeFichier, connectedParticipant, referentielVersion);

        try ( Connection connection = new DBConnection(dataSource).connection()) {
            connection.setAutoCommit(false);
            
            new FdxApiTable(codeTypeFichier,
                    referentielVersion,
                    connection)
                    .insert(data, dataProduction);
            connection.commit();
        }

    }

    private void deleteTokenTmp(TokenTmp tokenTmp) {
        List<TypeFichierDataTmp> dataTmp = dataTmpManager.getByToken(tokenTmp.getToken());
        for (TypeFichierDataTmp td : dataTmp) {
            dataTmpManager.delete(td);
        }
        TokenTmp t = tokenTmpManager.getById(tokenTmp.getToken());
        tokenTmpManager.delete(t);
    }

    private DataProduction newDataProduction(String codeTypeFichier, String codeParticipant, String referentielVersion) {
        DataProduction dataProduction = new DataProduction();
        dataProduction.setDateProduction(LocalDateTime.now());
        dataProduction.setReferentielVersion(referentielVersion);
        dataProduction.setCodeTypeFichier(codeTypeFichier);
        dataProduction.setCodeParticipant(codeParticipant);
        dataProduction.setSource(DataProductionSource.API);

        return dataProduction;
    }
}