import React, { Fragment, memo, useEffect, useState } from 'react';
import { useHistory, withRouter } from 'react-router-dom';
import { fechaPrimerDia, fechaUltimoDia, listaRangoNumeros } from '../../components/Util/Util.jsx';
import Config from '../../components/Util/constantes.js';
import { SiteRutas } from '../../request/RutasConfig.jsx';
import CierreAnualInt from './cierreAnualInt.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 ModalSpinner from '../../components/UI/modalSpinner/modalSpinner.jsx';
import ModalErrores from '../../components/UI/modalErrores/modalErrores.jsx';
import Swal from 'sweetalert2';
import {
    Contabilidad_CerrarPeriodo_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';

function CierreAnual(props) {

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

    const [Datos, setDatos] = useState({
        fecMesAno: { value: moment().toDate(), attributes: { readOnly: false, 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 } },
        Periodo: { value: "", attributes: { readOnly: true, focus: false, label: "Período", hidden: "unset" }, },
    });
    const [spinnerModal, setSpinnerModal] = useState(undefined);
    const [spinnerLabel, setSpinnerLabel] = useState('');
    const [spinnerTipo, setSpinnerTipo] = useState(3);

    //Seguridad
    const [usuarioS, setUsuarioS] = useSessionStorage('UsuarioSCON');
    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 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);
        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: () => validaSeguridad(),
            leyenda: "",
            iclase: faCheck,
            tooltip: "Aceptar"
        }
    ];

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

        let validar = validarMenuOpcion(opcionValidar);

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

    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);

    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.CierreAnual.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 };

            if (_datosEmpresa) {
                let e = new Date(_datosEmpresa.InicioPeriodo)
                e.setMonth(e.getMonth() + 11);
                let finPeriodo = e.getFullYear() + "/" + (e.getMonth() + 1) + "/" + e.getDate();

                setDatosEmpresa(_datosEmpresa);
                //_Datos.fecMesAno.value = moment(_datosEmpresa.InicioPeriodo).toDate();
                _Datos.Periodo.value = `${moment(_datosEmpresa.InicioPeriodo).format(Config.formatoFechaStandard)} al ${moment(finPeriodo).format(Config.formatoFechaStandard)}`;
            }

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

    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 handleAceptarSel = (Periodo) => {

        let resultado = false;

        Swal.fire({
            title: 'Atención',
            html: '<h4>¿Está seguro de querer cerrar el período fiscal actual?</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) {
                resultado = true;
                CerrarPeriodo();
            } else if (result.dismiss === Swal.DismissReason.cancel) {
                resultado = false;
            }
        });

    }

    const CerrarPeriodo = async () => {

        try {

            spinnerModalMostrar(true, `Aplicando Cierre Anual`, 3);

            const response = await Contabilidad_CerrarPeriodo_Request(token, empresa, usuario);

            if (response.Exitoso) {
                Notificacion.success('Proceso finalizado con Éxito.');
                volverAtras();
            } else {
                Notificacion.error(response.Mensaje);
                volverAtras();
            }

        } catch (ex) {
            console.log('Error en cierre anual', ex);
            Notificacion.error('Ocurrió un error Aplicando el cierre Anual.');
            volverAtras();
        }
        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);

    }

    return (
        <Fragment>
            <CierreAnualInt
                titulo={"Cierre Anual"}
                Datos={Datos}
                botones={botones}
                onhandleChangeDate={onhandleChangeDate}
            />
            <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}
            />
            <BotonArriba Delay={10} Visible={100} />
        </Fragment>

    );

};

export default withRouter(memo(CierreAnual));