package sgpp.services.acp.graficos.adapter;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

import org.apache.commons.lang3.StringUtils;

import sgpp.services.acp.DadosGraficoDTO;
import sgpp.services.acp.contrato.adapter.TPDateComparator;
import sgpp.services.acp.graficos.dto.GraficoAcumuladoExcedentesDTO;
import sgpp.services.acp.memoriacalculo.MemoriaCalculoEntity;
import sgpp.services.acp.memoriacalculo.SortByMes;
import sgpp.services.acp.memoriacalculo.html.DadosMemoriaCalculoBO;
import sgpp.services.acp.pap.PAPEntity;
import sgpp.services.acp.pap.PrevisaoProducaoEntity;
import sgpp.services.acp.pap.SortByAnoReferencia;
import sgpp.services.contrato.ContratoEntity;
import sgpp.services.contrato.TractParticipationEntity;

public class GraficoAcumuladoExcedentesDTOAdapter {

        private static BigDecimal aliquotaMediaUniao = BigDecimal.ZERO;
        private static BigDecimal trackParticipation = BigDecimal.ZERO;
        private static BigDecimal CEM = new BigDecimal("100");
        private static BigDecimal BBL = new BigDecimal("6.289811");
        private static int verificadorMes;

    public static GraficoAcumuladoExcedentesDTO getDados(List<PAPEntity> papList, List<MemoriaCalculoEntity> mcList, List<ContratoEntity> contratos, String anoInicial, String anoFinal, String mesInicial, String mesFinal, String corRealizado, String corPrevisto, String unidadeMedida) {
        if (papList == null || mcList == null || contratos == null || contratos.isEmpty()) return null;

        //checa se o contrato possui os campos de porcentagem para os calculos
        if (contratos.get(0).getCampos() != null && !contratos.get(0).getCampos().isEmpty()) {
            if (contratos.get(0).getCampos().get(0).getExcedenteUniaoContratado() != null) {
                aliquotaMediaUniao = contratos.get(0).getCampos().get(0).getExcedenteUniaoContratado();
            } else throw new RuntimeException("O contrato não possui o valor \"Excedente União Contratado\"");


            if (contratos.get(0).getCampos().get(0).getTractParticipations() != null && !contratos.get(0).getCampos().get(0).getTractParticipations().isEmpty()) {

                //TODO: track-participations vai ser alterado
                String data = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
                Optional<TractParticipationEntity> track = contratos.get(0).getCampos().get(0).getTractParticipations().stream().max(new TPDateComparator());
                if (track.isPresent()) {
                    if (data.compareTo(track.get().getDataFim().substring(0, 10)) < 0) {
                        trackParticipation = track.get().getPercentual().divide(CEM);
                    }
                } else {
                    track = contratos.get(0).getTractParticipations().stream().max(new TPDateComparator());
                    if (track.isPresent()) {
                        if (data.compareTo(track.get().getDataFim().substring(0, 10)) < 0) {
                            trackParticipation = track.get().getPercentual().divide(CEM);
                        }
                    }
                }
            }
        }

        //inicia o DTO
        GraficoAcumuladoExcedentesDTO dadosGrafico = new GraficoAcumuladoExcedentesDTO();
        dadosGrafico.setExcedenteGasPrevisto(new DadosGraficoDTO(null, corPrevisto, new ArrayList<BigDecimal>()));
        dadosGrafico.setExcedenteOleoPrevisto(new DadosGraficoDTO(null, corPrevisto, new ArrayList<BigDecimal>()));
        dadosGrafico.setExcedenteGasRealizado(new DadosGraficoDTO(null, corRealizado, new ArrayList<BigDecimal>()));
        dadosGrafico.setExcedenteOleoRealizado(new DadosGraficoDTO(null, corRealizado, new ArrayList<BigDecimal>()));

        //constroi o eixoX
        //OBS: o tamanho do eixo X é usado como parametro para inserção de zeros em meses sem memoria de calculo
        dadosGrafico.setEixoX(constroiEixoX(anoInicial, anoFinal, mesInicial, mesFinal));

        if (anoInicial.equals(anoFinal)) {
            dadosGrafico = recuperaValores(dadosGrafico, papList.isEmpty() ? new PAPEntity() : papList.get(0), mcList, unidadeMedida, mesInicial, mesFinal);

            if (mcList.isEmpty()) {
                dadosGrafico = zeraVolumes(dadosGrafico);
            }

        } else {
            papList.sort(new SortByAnoReferencia());

            List<MemoriaCalculoEntity> mcAnoInicial = mcList.stream()
            .filter(mc -> mc.getAno().equals(anoInicial))
            .collect(Collectors.toList());
            mcAnoInicial.sort(new SortByMes());

            List<MemoriaCalculoEntity> mcAnoFinal = mcList.stream()
            .filter(mc -> !mc.getAno().equals(anoInicial))
            .collect(Collectors.toList());
            mcAnoFinal.sort(new SortByMes());

            if (!papList.isEmpty()) {
                if (papList.size() > 1) {
                    dadosGrafico = recuperaValores(dadosGrafico, papList.get(0), mcAnoInicial, unidadeMedida, mesInicial, "12");
                    dadosGrafico = recuperaValores(dadosGrafico, papList.get(1), mcAnoFinal, unidadeMedida, "01", mesFinal);
                } else {
                    if (papList.get(0).getAnoReferencia().trim().equals(anoInicial.trim())) {
                        dadosGrafico = recuperaValores(dadosGrafico, papList.get(0), mcAnoInicial, unidadeMedida, mesInicial, "12");
                        dadosGrafico = recuperaValores(dadosGrafico, new PAPEntity(), mcAnoFinal, unidadeMedida, "01", mesFinal);
                    } else {
                        dadosGrafico = recuperaValores(dadosGrafico, new PAPEntity(), mcAnoInicial, unidadeMedida, mesInicial, "12");
                        dadosGrafico = recuperaValores(dadosGrafico, papList.get(0), mcAnoFinal, unidadeMedida, "01", mesFinal);
                    }
                }
            }
        }

        dadosGrafico.getExcedenteGasPrevisto().setTipo("Previsto");
        dadosGrafico.getExcedenteGasRealizado().setTipo("Realizado");
        dadosGrafico.getExcedenteOleoPrevisto().setTipo("Previsto");
        dadosGrafico.getExcedenteOleoRealizado().setTipo("Realizado");

        dadosGrafico = acumulaValores(dadosGrafico);

        return dadosGrafico;
    }

    private static GraficoAcumuladoExcedentesDTO recuperaValores(GraficoAcumuladoExcedentesDTO dto, PAPEntity pap, List<MemoriaCalculoEntity> mcList, String unidadeMedida, String mesInicial, String mesFinal) {

        List<PrevisaoProducaoEntity> prodPap = pap.getProducaoMensal();

        DadosGraficoDTO dadosGasRealizado = dto.getExcedenteGasRealizado();
        DadosGraficoDTO dadosOleoRealizado = dto.getExcedenteOleoRealizado();
        DadosGraficoDTO dadosGasPrevisto =  dto.getExcedenteGasPrevisto();
        DadosGraficoDTO dadosOleoPrevisto = dto.getExcedenteOleoPrevisto();

        verificadorMes = Integer.parseInt(mesInicial);
        int mesFinalInt = Integer.parseInt(mesFinal);

        if (mcList != null) mcList.stream().forEach(mc -> {

            BigDecimal valorEGURealizado = new BigDecimal("0.00");
            BigDecimal valorEOURealizado = new BigDecimal("0.00");
            BigDecimal valorEGUPrevisto = new BigDecimal("0.00");
            BigDecimal valorEOUPrevisto = new BigDecimal("0.00");

            BigDecimal percExcedente = BigDecimal.ZERO;

            int mesMC = Integer.parseInt(mc.getMes());

            while (verificadorMes < mesMC) {
                dadosGasRealizado.getVolumesMensais().add(valorEOURealizado);
                dadosOleoRealizado.getVolumesMensais().add(valorEOURealizado);
                dadosGasPrevisto.getVolumesMensais().add(valorEGUPrevisto);
                dadosOleoPrevisto.getVolumesMensais().add(valorEOUPrevisto);
                verificadorMes++;
                if (verificadorMes == mesFinalInt) break;
            }

            List<DadosMemoriaCalculoBO>  dadosODMPercExcedente = new ArrayList<>();
            List<DadosMemoriaCalculoBO>  dadosODMValorGas = new ArrayList<>();
            List<DadosMemoriaCalculoBO>  dadosODMValorOleo = new ArrayList<>();

            if (mc.getDadosODM() != null && Integer.parseInt(mc.getMes()) == verificadorMes) {
                dadosODMPercExcedente =  mc.getDadosODM()
                    .stream()
                    .filter(d -> StringUtils.containsIgnoreCase(d.getSigla(), "EO% m"))
                    .collect(Collectors.toList());

                dadosODMValorOleo =  mc.getDadosODM()
                    .stream()
                    .filter(d -> StringUtils.containsIgnoreCase(d.getSigla(), "EOU m+1"))
                    .collect(Collectors.toList());

                dadosODMValorGas =  mc.getDadosODM()
                    .stream()
                    .filter(d -> StringUtils.containsIgnoreCase(d.getSigla(), "EGU m+1"))
                    .collect(Collectors.toList());

            }

            if (!dadosODMPercExcedente.isEmpty() && dadosODMPercExcedente.get(0).getValor() != null) percExcedente = dadosODMPercExcedente.get(0).getValor();

            if (!dadosODMValorOleo.isEmpty() && dadosODMValorOleo.get(0).getValor() != null) valorEOURealizado = dadosODMValorOleo.get(0).getValor();
            if (!dadosODMValorGas.isEmpty() && dadosODMValorGas.get(0).getValor() != null) valorEGURealizado = dadosODMValorGas.get(0).getValor();

            //ADICIONA VALORES AO DTO
            dadosGasRealizado.getVolumesMensais().add(valorEGURealizado.setScale(2, BigDecimal.ROUND_HALF_EVEN));
            dadosOleoRealizado.getVolumesMensais().add(unidadeMedida.equals("1") ? valorEOURealizado.multiply(BigDecimal.valueOf(6.289811)).setScale(2, BigDecimal.ROUND_HALF_EVEN) : valorEOURealizado.setScale(2, BigDecimal.ROUND_HALF_EVEN));

            if (prodPap != null && Integer.parseInt(mc.getMes()) == verificadorMes) {
                try {

                    BigDecimal percentual = trackParticipation.multiply(aliquotaMediaUniao.multiply(percExcedente));

                    int index = Integer.parseInt(mc.getMes()) - 1;
                    valorEGUPrevisto = prodPap.get(index).getGasAssociado().multiply(percentual);

                    valorEOUPrevisto = prodPap.get(index).getOleo().multiply(percentual);
                } catch (IndexOutOfBoundsException e) {
                    throw new RuntimeException("Há algo de arrado com as produções mensais do PAP de " + pap.getAnoReferencia() + "!");
                }
            }

            //ADICIONA VALORES AO DTO
            dadosGasPrevisto.getVolumesMensais().add(valorEGUPrevisto.setScale(2, BigDecimal.ROUND_HALF_EVEN));
            dadosOleoPrevisto.getVolumesMensais().add(unidadeMedida.equals("1") ? valorEOUPrevisto.multiply(BBL).setScale(2, BigDecimal.ROUND_HALF_EVEN) : valorEOUPrevisto.setScale(2, BigDecimal.ROUND_HALF_EVEN));

            verificadorMes++;
        });



        if(mcList == null || mcList.isEmpty()) {
            for(int i = 0; i < retornaQuantidadeMeses(mesInicial, mesFinal); i++ ){
                dadosGasRealizado.getVolumesMensais().add(new BigDecimal("0.00"));
                dadosOleoPrevisto.getVolumesMensais().add(new BigDecimal("0.00"));
                dadosGasPrevisto.getVolumesMensais().add(new BigDecimal("0.00"));
                dadosOleoRealizado.getVolumesMensais().add(new BigDecimal("0.00"));
            }
        } else {
            int mesInicialInt = Integer.parseInt(mesInicial);
            int intervalo = mesFinalInt - mesInicialInt + 1;
            int tamanho = verificadorMes - mesInicialInt;
            if (intervalo != tamanho) {
                for (int i = 0; i < intervalo-tamanho; i++) {
                    dadosGasRealizado.getVolumesMensais().add(new BigDecimal("0.00"));
                    dadosOleoRealizado.getVolumesMensais().add(new BigDecimal("0.00"));
                    dadosGasPrevisto.getVolumesMensais().add(new BigDecimal("0.00"));
                    dadosOleoPrevisto.getVolumesMensais().add(new BigDecimal("0.00"));
                }
            }
        }


        dto.setExcedenteGasPrevisto(dadosGasPrevisto);
        dto.setExcedenteGasRealizado(dadosGasRealizado);
        dto.setExcedenteOleoPrevisto(dadosOleoPrevisto);
        dto.setExcedenteOleoRealizado(dadosOleoRealizado);

        return dto;
    }

    private static List<String> constroiEixoX(String anoInicial, String anoFinal, String mesInicial, String mesFinal){
        List<String> meses = new ArrayList<>();

        if (anoInicial.equals(anoFinal)){
            meses.addAll(constroiUmAno(mesInicial, mesFinal, anoInicial));
        } else {
            meses.addAll(constroiUmAno(mesInicial, "12", anoInicial));
            meses.addAll(constroiUmAno("1", mesFinal, anoFinal));
        }

        return meses;
    }

    private static List<String> constroiUmAno(String mesInicial, String mesFinal, String ano){
        int intInicial = Integer.parseInt(mesInicial);
        int intFinal = Integer.parseInt(mesFinal);

        List<String> meses = new ArrayList<>();

        for (int i = intInicial; i <= intFinal; i++){
            meses.add(retornaLabelMes(i, ano));
        }

        return meses;

    }

    private static String retornaLabelMes(int mes, String ano){
        StringBuilder sb = new StringBuilder();
        switch (mes) {
            case 1:
                sb.append("jan");
                break;
            case 2:
                sb.append("fev");
                break;
            case 3:
                sb.append("mar");
                break;
            case 4:
                sb.append("abr");
                break;
            case 5:
                sb.append("mai");
                break;
            case 6:
                sb.append("jun");
                break;
            case 7:
                sb.append("jul");
                break;
            case 8:
                sb.append("ago");
                break;
            case 9:
                sb.append("set");
                break;
            case 10:
                sb.append("out");
                break;
            case 11:
                sb.append("nov");
                break;
            case 12:
                sb.append("dez");
                break;
            default:
                break;
        }
        sb.append("/");
        sb.append(ano.substring(2));

        return sb.toString();
    }


    private static GraficoAcumuladoExcedentesDTO acumulaValores(GraficoAcumuladoExcedentesDTO dadosGrafico) {

        BigDecimal acumuladoGasPrevisto = BigDecimal.ZERO;
        BigDecimal acumuladoGasRealizado = BigDecimal.ZERO;
        BigDecimal acumuladoOleoPrevisto = BigDecimal.ZERO;
        BigDecimal acumuladoOleoRealizado = BigDecimal.ZERO;

        List<BigDecimal> auxiliarGasPrevisto = new ArrayList<>();
        List<BigDecimal> auxiliarGasRealizado = new ArrayList<>();
        List<BigDecimal> auxiliarOleoPrevisto = new ArrayList<>();
        List<BigDecimal> auxiliarOleoRealizado = new ArrayList<>();

        int tamanho = dadosGrafico.getEixoX().size();

        for (int i = 0; i < tamanho; i++) {
            acumuladoGasPrevisto = acumuladoGasPrevisto.add(dadosGrafico.getExcedenteGasPrevisto().getVolumesMensais().get(i));
            acumuladoGasRealizado = acumuladoGasRealizado.add(dadosGrafico.getExcedenteGasRealizado().getVolumesMensais().get(i));
            acumuladoOleoPrevisto = acumuladoOleoPrevisto.add(dadosGrafico.getExcedenteOleoPrevisto().getVolumesMensais().get(i));
            acumuladoOleoRealizado = acumuladoOleoRealizado.add(dadosGrafico.getExcedenteOleoRealizado().getVolumesMensais().get(i));

            auxiliarGasPrevisto.add(acumuladoGasPrevisto);
            auxiliarGasRealizado.add(acumuladoGasRealizado);
            auxiliarOleoPrevisto.add(acumuladoOleoPrevisto);
            auxiliarOleoRealizado.add(acumuladoOleoRealizado);
        }

        dadosGrafico.getExcedenteGasPrevisto().setVolumesMensais(auxiliarGasPrevisto);
        dadosGrafico.getExcedenteGasRealizado().setVolumesMensais(auxiliarGasRealizado);
        dadosGrafico.getExcedenteOleoPrevisto().setVolumesMensais(auxiliarOleoPrevisto);
        dadosGrafico.getExcedenteOleoRealizado().setVolumesMensais(auxiliarOleoRealizado);

        return dadosGrafico;
    }

    private static GraficoAcumuladoExcedentesDTO zeraVolumes(GraficoAcumuladoExcedentesDTO dadosGrafico) {
        dadosGrafico.getExcedenteGasPrevisto().setVolumesMensais(new ArrayList<>());
        dadosGrafico.getExcedenteGasRealizado().setVolumesMensais(new ArrayList<>());
        dadosGrafico.getExcedenteOleoPrevisto().setVolumesMensais(new ArrayList<>());
        dadosGrafico.getExcedenteOleoRealizado().setVolumesMensais(new ArrayList<>());
        for (int i = 0; i < dadosGrafico.getEixoX().size(); i++) {
            dadosGrafico.getExcedenteGasPrevisto().getVolumesMensais().add(BigDecimal.ZERO);
            dadosGrafico.getExcedenteGasRealizado().getVolumesMensais().add(BigDecimal.ZERO);
            dadosGrafico.getExcedenteOleoPrevisto().getVolumesMensais().add(BigDecimal.ZERO);
            dadosGrafico.getExcedenteOleoRealizado().getVolumesMensais().add(BigDecimal.ZERO);
        }
        return dadosGrafico;
    }

    private static int retornaQuantidadeMeses(String mesInicial, String mesFinal) {
        return Integer.parseInt(mesFinal) -Integer.parseInt(mesInicial) + 1;
    }
}