import React, { Fragment, memo, useEffect, useState } from 'react';
import { useHistory, withRouter } from 'react-router-dom';
import { fechaPrimerDia, fechaUltimoDia, listaRangoNumeros, itemSelect } from '../../components/Util/Util.jsx';
import Config from '../../components/Util/constantes.js';
import { SiteRutas } from '../../request/RutasConfig.jsx';
import CierreMensualInt from './cierreMensualInt.jsx';
import BotonArriba from '../../components/UI/botonArriba/botonArriba.jsx';
import { faCheck, faReply, } from '@fortawesome/free-solid-svg-icons';
import { useSessionStorage } from '../../components/Util/Hooks/useSessionStorage.jsx';
import { Notificacion } from '../../components/Util/Notificacion/Notificacion.jsx';
import ModalAsientosCierre from '../../components/UI/modalAsientosDelCierre/modalAsientosCierre.jsx';
import ModalSpinner from '../../components/UI/modalSpinner/modalSpinner.jsx';
import ModalErrores from '../../components/UI/modalErrores/modalErrores.jsx';
import { MesesCerrados_Consulta_Request } from '../../request/ServicioRequest.jsx';
import Swal from 'sweetalert2';
import {
    Contabilidad_HayAuxiliaresSinCerrar_Request, Contabilidad_CerrarMes_Request
} from '../../request/MantenimientosRequest.jsx';
import { Empresa_Consulta_Request } from "../../request/SeguridadRequest.jsx";
import { Obtener_MenuOpciones_Lista_Request, Obtener_MenuNombre_Request } from "../../request/MenuRequest.jsx";
import ModalSeguridad from "../Seguridad/ModalSeguridad.jsx";
import optSeg from '../../components/Util/seg-menu-opciones.js';
import moment from 'moment';
import { Get_Description_Report_Request, SetParametrosReporte_Request } from '../../request/ReportesRequest.jsx';

function CierreMensual(props) {

    let historyMenu = useHistory();
    const [empresa, setEmpresa] = useSessionStorage('empresaCON', 0);
    const [empresaNombre, setEmpresaNombre] = useSessionStorage('empresaNombreCON', '');
    const [datosEmpresa, setDatosEmpresa] = useState(null);
    const [token, setToken] = useSessionStorage('tokenCON', '');
    const [usuario, setUsuario] = useSessionStorage('usuarioCON');
    const [paisCON, setPaisCON] = useSessionStorage('paisCON');
    const _AnnoActual = new Date().getFullYear();
    const _ListaAnnos = listaRangoNumeros(Config.anoAntiguedad, _AnnoActual);

    const [Datos, setDatos] = useState({
        fecMesAno: { value: moment().toDate(), attributes: { readOnly: true, focus: false, label: 'Período', hidden: 'unset', minDate: fechaPrimerDia(new Date(Config.anoAntiguedad, 0, 1)), maxDate: fechaUltimoDia(new Date(_AnnoActual, 11, 1)), ListaAnnos: _ListaAnnos, formatDate: Config.formatoMesAno } },
    });
    const [DatosImp, setDatosImp] = useState({
        ImprimirLogo: { value: false, attributes: { readOnly: false, focus: false, label: 'Imprimir Logo', hidden: 'unset' } },
        fecMesAno: { value: moment().toDate(), attributes: { readOnly: true, focus: false, label: 'Período', hidden: 'unset', minDate: fechaPrimerDia(new Date(Config.anoAntiguedad, 0, 1)), maxDate: fechaUltimoDia(new Date(_AnnoActual, 11, 1)), ListaAnnos: _ListaAnnos, formatDate: Config.formatoMesAno } },
    });
    const [spinnerModal, setSpinnerModal] = useState(undefined);
    const [spinnerLabel, setSpinnerLabel] = useState('');
    const [spinnerTipo, setSpinnerTipo] = useState(3);

    //Seguridad
    const [usuarioS, setUsuarioS] = useSessionStorage('UsuarioSCON');
    const [usuarioNombreCON, setUsuarioNombreCON] = useSessionStorage('usuarioNombreCON');
    const [menuId, setMenuId] = useState(0);
    const [menuOpciones, setMenuOpciones] = useState([]);
    const [showModalSeguridad, setShowModalSeguridad] = useState(false);
    const [opcionValidar, setOpcionValidar] = useState(0);
    const [opcionValidarNombre, setOpcionValidarNombre] = useState('');

    const [selectModalEr, setSelectModalEr] = useState(false);
    const [openModalRep, setOpenModalRep] = useState(false);
    const cellEditEr = { mode: '', blurToSave: false, autoSelectText: false };
    const columnasEr = [{ dataField: 'Campo1', text: 'Empresa', sort: true },
    { dataField: 'Campo2', text: 'Modulo', sort: true },
    { dataField: 'Campo3', text: 'Mensaje de Error', sort: true }];
    const [listaErrores, setListaErrores] = useState([]);

    const selectRowEr = { mode: '', clickToSelect: false, hideSelectColumn: true, onSelect: () => { } };

    const cerrarModalEr = () => {
        setSelectModalEr(false);
    }

    const cerrarModalRep = () => {
        setOpenModalRep(false);
        volverAtras();
    }

    const botones = [
        {
            name: "btnHomeC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => volverAtras(),
            leyenda: "",
            iclase: faReply,
            tooltip: "Volver"
        },
        {
            name: "btnAceptar",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => validaSeguridadCierre(),
            leyenda: "",
            iclase: faCheck,
            tooltip: "Aceptar"
        }
    ];

    const spinnerModalMostrar = (pSpinnerModal, pSpinnerLabel, pSpinnerTipo) => {
        setSpinnerModal(pSpinnerModal);
        setSpinnerLabel(pSpinnerLabel);
        setSpinnerTipo(pSpinnerTipo);
    };

    //Seguridad
    const cargarMenuOpciones = async (pModuloId, pUsuarioId, pMenuId) => {
        try {

            let listMO = await Obtener_MenuOpciones_Lista_Request(token, pModuloId, pUsuarioId, pMenuId);
            if (listMO.Exitoso === false) {
                return null;
            }
            return listMO.Datos;
        }
        catch (err) {
            Notificacion.error(`Error: cargarMenuOpciones.`);
        }
    };

    const cargarMenuNombre = async (pModulo, pMenuNombre) => {
        try {
            let listMON = await Obtener_MenuNombre_Request(token, pModulo, pMenuNombre);
            if (listMON.Exitoso == false) {
                return null;
            }
            return listMON.Datos;
        }
        catch (err) {
            Notificacion.error(`Error: cargarMenuNombre.`);
        }
    };

    const validarMenuOpcion = (pOpcion) => {
        let validar = false;
        let _menuOpciones = menuOpciones;
        let resultado = _menuOpciones.filter((item) => item.Opcion_Nombre == pOpcion);
        if (resultado.length > 0) {
            if (resultado[0].Opcion_Validar) {
                setShowModalSeguridad(true); setOpcionValidar(resultado[0].Opcion_Id); setOpcionValidarNombre(pOpcion);
                validar = true;
            }
        } else {
            setShowModalSeguridad(true); setOpcionValidar(resultado[0].Opcion_Id); setOpcionValidarNombre(pOpcion);
            validar = true;
        }
        return validar;
    };

    const handleCerrarModal = () => {
        setShowModalSeguridad(false);
        //volverAtras();
    }

    const onActionResultModal = (pValido) => {
        if (pValido) {
            let _OpcionNom = opcionValidarNombre;
            setShowModalSeguridad(false); setOpcionValidar(0); setOpcionValidarNombre('');
            const _optSegopt = optSeg.TOpciones_Menu;

            switch (_OpcionNom) {
                case _optSegopt.Aplicar.value:
                    handleAceptarSel();
                    break;
                default:
                    break;
            }
        }
    };

    useEffect(() => {

        const carga = async () => {
            await cargarDatos();
        }
        carga();

    }, []);

    const cargarSeguridad = async () => {
        const _MenuNomb = await cargarMenuNombre(Config.Modulo, optSeg.TMenuSistema.CierreMensual.value);
        let _menuId = 0;

        if (_MenuNomb.ID != undefined) {
            _menuId = _MenuNomb.ID;
        }

        let _menuOpciones = null;
        if (_menuId > 0) {
            _menuOpciones = await cargarMenuOpciones(Config.Modulo, usuarioS, _menuId);
        }
        setMenuId(_menuId), setMenuOpciones(_menuOpciones);

        return { menuId: _menuId, menuOpciones: _menuOpciones };

    }

    const cargarDatos = async () => {

        try {
            spinnerModalMostrar(true, 'Cargando Datos', 3);

            const _datosEmpresa = await cargarEmpresa();
            await cargarSeguridad();

            let _Datos = { ...Datos };
            let _DatosImp = { ...DatosImp };

            if (_datosEmpresa) {
                setDatosEmpresa(_datosEmpresa);
                _Datos.fecMesAno.value = moment(_datosEmpresa.Periodo).toDate();
                _DatosImp.fecMesAno.value = moment(_datosEmpresa.Periodo).toDate();
            }

        } catch (e) {
            console.log('error ', e);
            Notificacion.error("Ocurrió un error cargando los datos.");
        }
        finally {
            spinnerModalMostrar(false, '', 3);
        }
    };

    const validaSeguridadCierre = () => {
        const optSegopt = optSeg.TOpciones_Menu;
        let opcionValidar = optSegopt.Aplicar.value;

        let validar = validarMenuOpcion(opcionValidar);

        if (!validar) {
            handleAceptarSel(Datos.fecMesAno.value);
        }
    };

    const volverAtras = () => {
        historyMenu.push(SiteRutas.Asientos);
    }

    const cargarEmpresa = async () => {
        let response = await Empresa_Consulta_Request(token, empresa);

        if (response.Exitoso) {
            return (response.Datos);
        } else {
            Notificacion.error(response.Mensaje);
            volverAtras();
        }
        return null;
    };

    const handleAceptar = async () => {

        spinnerModalMostrar(true, `Consultando Datos...`, 3);

        let _Datos = { ...DatosImp };
        const empresaId = datosEmpresa.Id;
        let periodo = _Datos.fecMesAno.value;

        const formato = moment(periodo).format(Config.formatoFechaAMD);
        const fecha = moment(periodo).format(Config.formatoFechaStandard);

        //validar meses cerrados
        let respuesta = await MesesCerrados_Consulta_Request(token, empresaId, formato);

        if (respuesta.Exitoso) {

            if (respuesta.Datos.Empresa !== 0 && respuesta.Datos.Periodo !== "1900-01-01T00:00:00") {

                let titulo = "";
                //Continua

                const ReporteDesc = await obtieneDescripcionReporte(token, Config.Reportes.AsientosDelCierre);

                if (ReporteDesc.Exitoso) {
                    titulo = ReporteDesc.Datos.ReportTitulo;
                } else {
                    Notificacion.error("Sucedió un error al consultar los datos del reporte.");
                    volverAtras();
                    return;
                }

                let imprimirLogo = DatosImp.ImprimirLogo.value;

                const params = parametrosAsientos(empresa, empresaNombre, fecha, titulo, usuarioNombreCON, imprimirLogo);

                let data = await SetParametrosReporte_Request(token, params);

                const myWindow = window.open();

                if (myWindow === null) {
                    Notificacion.error("Error: No se puede redireccionar al reporte.");
                    return;
                }

                if (data.hasOwnProperty("Error")) {
                    Notificacion.error(`${data.Error}`);
                } else {
                    setTimeout(() => {
                        myWindow.location.replace(
                            `../../../ReportesSSR/MuestraReporte.aspx?ReporteId=${Config.Reportes.AsientosDelCierre}&Empresa=${empresa}&Pais=${paisCON}`
                        );
                    }, 1);
                }
                //}

            } else {
                Notificacion.error("No es posible imprimir el reporte de un periodo que no ha sido concluido.");
            }

        } else {
            Notificacion.error("Sucedió un error al consultar los datos del periodo.");
        }

        spinnerModalMostrar(false, ``, 3);

    }

    const obtieneDescripcionReporte = async (pToken, pReporte) => {
        let datos = await Get_Description_Report_Request(pToken, pReporte);
        return datos;
    };

    const handleAceptarSel = (Periodo) => {

        const _Periodo = Periodo ?? datosEmpresa.Periodo;

        const NombreMes = itemSelect(moment(_Periodo).month() + 1, Config.listaMeses).label;

        Swal.fire({
            title: 'Atención',
            html: '<h4>¿Está seguro de querer cerrar el período "' + NombreMes + ', ' + moment(_Periodo).year() + '"?</h4>',
            type: 'question',
            showCancelButton: true,
            confirmButtonColor: '#10a599',
            cancelButtonColor: '#d33',
            confirmButtonText: '<h5><i class="fa fa-check fa-fw"></i> Sí</h5>',
            cancelButtonText: '<h5><i class="fa fa-remove fa-fw"></i> No</h5>',
            reverseButtons: true,
            allowOutsideClick: false,
        }).then((result) => {
            if (result.value) {
                CerrarMes();
            } else if (result.dismiss === Swal.DismissReason.cancel) {
            }
        });

    }

    const parametrosAsientos = (Empresa, NombreEmpresa, Fecha, ReportNombre, UsuarioNombre, imprimirLogo) => {

        let Resumen = '';
        let IncluirResumen = false;

        return {
            Empresa,
            NombreEmpresa,
            Fecha,
            ReportNombre,
            Resumen,
            UsuarioNombre,
            IncluirResumen,
            imprimirLogo
        };

    };

    const CerrarMes = async () => {
        try {
            spinnerModalMostrar(true, `Aplicando Cierre Mensual`, 3);
            let response = await Contabilidad_HayAuxiliaresSinCerrar_Request(token, empresa);

            if (response.Exitoso) {

                if (response.Datos.length > 0) {
                    setListaErrores(response.Datos);
                    setSelectModalEr(true);
                } else {
                    //si no hay errores se continua el proceso

                    response = await Contabilidad_CerrarMes_Request(token, empresa, usuario);

                    if (response.Exitoso) {

                        const _datosEmpresa = await cargarEmpresa();

                        if (moment(_datosEmpresa.Periodo).toDate() > moment(datosEmpresa.FinPeriodo).toDate()) {
                            Notificacion.info('No olvide que debe cerrar el periodo fiscal para poder aplicar asientos en el nuevo periodo.');
                        }

                        Notificacion.success('Se realizó el cierre mensual del periodo seleccionado correctamente.');
                        setOpenModalRep(true);
                        //volverAtras();
                    } else {
                        Notificacion.error(response.Mensaje);
                    }
                }
            }
        } catch (ex) {
            console.log('Error en cierre mensual', ex);
            Notificacion.error('Ocurrió un error Aplicando el cierre Mensual.');
        }
        finally {
            spinnerModalMostrar(false, '', 3);
        }
    }

    const onhandleChangeDate = async (date, id) => {
        const name = id;
        const value = date;
        let newAttributes = Datos[name].attributes;

        const _Datos = Object.assign({}, Datos, { [name]: { value: value, attributes: newAttributes } });

        setDatos(_Datos);

    }

    const handleCheckBox = (event) => {
        const name = event.target.name;
        const value = event.target.checked;
        let newAttributes = DatosImp[name].attributes;

        let _Datos = Object.assign({}, Datos, {
            [name]: { value: value, attributes: newAttributes },
        });

        setDatosImp(_Datos);
    };

    return (
        <Fragment>
            <CierreMensualInt
                titulo={"Cierre Mensual"}
                Datos={Datos}
                botones={botones}
                onhandleChangeDate={onhandleChangeDate}
                handleCheckBox={handleCheckBox}
            />
            <ModalSpinner
                selectedModal={spinnerModal}
                contentLabel={'spinnerModalProgress'}
                label={spinnerLabel}
                tipoSpinner={spinnerTipo}
            />
            <ModalSeguridad
                modalTitle={'Requiere Permisos'}
                menuId={menuId}
                opcionId={opcionValidar}
                show={showModalSeguridad}
                onActionResult={onActionResultModal}
                onHide={handleCerrarModal}
            />
            <ModalErrores
                selectedModal={selectModalEr}
                contentLabel={'listaErrores'}
                datos={listaErrores}
                id={'Campo3'}
                columnas={columnasEr}
                striped={false}
                hover={true}
                condensed={false}
                selectRow={selectRowEr}
                label={'Errores Detectados'}
                cellEdit={cellEditEr}
                cerrarModal={cerrarModalEr}
                verLHOC={false}
            />

            <ModalAsientosCierre
                selectedModal={openModalRep}
                contentLabel={'Asientos del Cierre'}
                Datos={DatosImp}
                label={'Asientos del Cierre'}
                cerrarModal={cerrarModalRep}
                handleCheckBox={handleCheckBox}
                handleAceptar={handleAceptar}
                botones={[]}
            />

            <BotonArriba Delay={10} Visible={100} />
        </Fragment>

    );

};

export default withRouter(memo(CierreMensual));