package com.megatim.fdxcommons.tools.database.tables;

import com.megatim.fdxcommons.tools.database.tables.appcolumns.FdxConsultationColumnDefinitions;
import com.megatim.fdxcommons.model.dataproduction.CommonDataProduction;
import com.megatim.fdxcommons.model.enumeration.CriteriaLogicConnector;
import com.megatim.fdxcommons.model.enumeration.Operateur;
import com.megatim.fdxcommons.model.integration.ColumnDefinition;
import com.megatim.fdxcommons.tools.database.contrat.TypeFichierDataRow;
import com.megatim.fdxcommons.tools.database.contrat.TypeFichierInsertMetaData;
import com.megatim.fdxcommons.tools.database.exceptions.TypeFichierDataBadRequest;
import com.megatim.fdxcommons.tools.database.queries.CreateTableIfNotExistQuery;
import com.megatim.fdxcommons.tools.database.queries.DeleteTableDataQuery;
import com.megatim.fdxcommons.tools.database.queries.FdxConsultationInsert;
import com.megatim.fdxcommons.tools.database.queries.metadata.ConsultationTypeFichierInsertData;
import com.megatim.fdxcommons.tools.database.queries.metadata.DefaultTypeFichierDataRow;
import com.megatim.fdxcommons.tools.database.queries.metadata.QueryCriterion;
import com.megatim.fdxcommons.tools.database.tables.appcolumns.DataProductionIdColumnDefinition;
import com.megatim.fdxcommons.tools.database.tables.appcolumns.DataProductionUpdateIdColumnDefinition;
import com.megatim.fdxcommons.tools.database.tables.appcolumns.EnCoursProductionColumnDefinition;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.naming.NamingException;
import javax.transaction.Transactional;

/**
 *
 * @author ASUS
 */
public class FdxConsultationTable extends FdxTable {

    public FdxConsultationTable(String codeTypeFichier, String referentielVersion) {
        super(codeTypeFichier, referentielVersion);
    }

    @Override
    @Transactional
    public synchronized void createTable(List<ColumnDefinition> columnsDefinition, Connection connection) throws NamingException, SQLException, Exception {
        new CreateTableIfNotExistQuery(tableName, columnsDefinition, new FdxConsultationColumnDefinitions(), connection).execute();
    }

    public synchronized long insert(List<FdxTableRow> originalData, Long dataProductionId, Connection connection) throws TypeFichierDataBadRequest, SQLException, NamingException, Exception {
        if (originalData != null && !originalData.isEmpty()) {
            List<TypeFichierDataRow> rows = new ArrayList<>();
            originalData.stream().forEach(row -> {
                Map<String, Object> entity = new HashMap<>();
                row.getDataColumns().stream().forEach(cd -> {
                    entity.put(cd.getName(), cd.getValue());
                });
                rows.add(new DefaultTypeFichierDataRow(entity));
            });

            TypeFichierInsertMetaData insertMetaData = new ConsultationTypeFichierInsertData(rows, tableName.name(connection));
            return new FdxConsultationInsert(connection, dataProductionId).insert(insertMetaData);

        } else {
            return -1;
        }
    }

    public void removeUnCompleteData(Connection connection, Long dataProductionId) throws SQLException, Exception {

        QueryCriterion criterion = new QueryCriterion(null, null, null, CriteriaLogicConnector.AND,
                Arrays.asList(
                        new QueryCriterion(new EnCoursProductionColumnDefinition().name(), true, Operateur.EQUALS, null,
                                Arrays.asList(
                                        new QueryCriterion(null, null, null, CriteriaLogicConnector.OR,
                                                Arrays.asList(
                                                        new QueryCriterion(new DataProductionIdColumnDefinition().name(), dataProductionId, Operateur.EQUALS, null, Arrays.asList()),
                                                        new QueryCriterion(new DataProductionUpdateIdColumnDefinition().name(), dataProductionId, Operateur.EQUALS, null, Arrays.asList())
                                                )
                                        )
                                )
                        )
                )
        );

        new DeleteTableDataQuery(tableName.name(connection), connection, criterion).execute();
    }

    @Override
    public synchronized void deleteOne(QueryCriterion queryCriterion, CommonDataProduction dataProduction, Connection connection) throws TypeFichierDataBadRequest, SQLException, NamingException, Exception {
    }

    @Override
    public synchronized void updateOne(Map<String, Object> dataToUpdate, QueryCriterion queryCriterion, CommonDataProduction dataProduction, Connection connection) throws TypeFichierDataBadRequest, SQLException, NamingException, Exception {
    }

    @Override
    public synchronized void update(Map<String, Object> dataToUpdate, QueryCriterion queryCriterion, CommonDataProduction dataProduction, Connection connection) throws TypeFichierDataBadRequest, SQLException, NamingException, Exception {
    }
}