import React, { Fragment, memo, useState, useEffect, } from 'react';
import { useHistory, withRouter } from 'react-router-dom';
import Swal from 'sweetalert2';
import { faSave, faPlus, faReply, faTrash, faPen } from '@fortawesome/free-solid-svg-icons'

import { SiteRutas } from '../../request/RutasConfig.jsx';
import ModalSpinner from '../../components/UI/modalSpinner/modalSpinner.jsx';
import { useSessionStorage } from '../../components/Util/Hooks/useSessionStorage.jsx';
import optSeg from '../../components/Util/seg-menu-opciones.js'
import Config from '../../components/Util/constantes.js'
import { Notificacion } from '../../components/Util/Notificacion/Notificacion.jsx';
import { manageError } from '../../components/Util/ManageError.js';
import ModalSeguridad from "../Seguridad/ModalSeguridad.jsx";
import { muestraArbolEmpleados, validarDecimal, validarInt } from '../../components/Util/Util.jsx';

import { Obtener_MenuNombre_Request, Obtener_MenuOpciones_Lista_Request } from '../../request/MenuRequest.jsx';
import { GetListaJustificaciones, MantenimientoJustificaciones_Delete, MantenimientoJustificaciones_Guardar } from '../../request/RebajasRequest.jsx';

import MantenimientoJustificacionesInt from './mantenimientoJustificacionesInt.jsx';
import ModalJustificacionNuevoEdita from './modalJustificacionNuevoEdita.jsx';

export const mantenimientoJustificaciones = (props) => {

    const [token, setToken] = useSessionStorage('token', '');
    const [usuario, setUsuario] = useSessionStorage('usuario');
    const [usuarioS, setUsuarioS] = useSessionStorage('UsuarioS');
    const [menuId, setMenuId] = useState(0);
    const [menuOpciones, setMenuOpciones] = useState([]);
    const [spinnerModal, setSpinnerModal] = useState(undefined);
    const [spinnerLabel, setSpinnerLabel] = useState('');
    const [spinnerTipo, setSpinnerTipo] = useState(1);
    const [showModalSeguridad, setShowModalSeguridad] = useState(false);
    const [opcionValidar, setOpcionValidar] = useState(0);
    const [opcionValidarNombre, setOpcionValidarNombre] = useState('');

    const [listJustificaciones, setListJustificaciones] = useState([]);
    const [id, setID] = useState(0);
    const [fila, setFila] = useState([]);
    const [borrando, setBorrando] = useState(false);
    const [selectModal, setSelectModal] = useState(false);
    const [modoEdicion, setmodoEdicion] = useState(false);

    let historyMenu = useHistory();

    const empresa = JSON.parse(sessionStorage.getItem('empresa'));

    const botones = [
        {
            name: "btnHomeC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => volverAtras(),
            leyenda: "",
            iclase: faReply,
            tooltip: "Volver"
        },
        {
            name: "btnAgragarDetPre",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => onModificaNuevo("Nuevo"),
            leyenda: "",
            iclase: faPlus,
            tooltip: "Agregar"
        },
        {
            name: "btnModificarC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => onModificaNuevo("Edita"),
            leyenda: "",
            iclase: faPen,
            tooltip: "Modificar"
        },
        {
            name: "btnBorraDetPre",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => onBorrar(),
            leyenda: "",
            iclase: faTrash,
            tooltip: "Borrar"
        },
    ]

    const botonesMod = [
        {
            name: "btnHomeC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => cerraModalEdicionNuevo(),
            leyenda: "",
            iclase: faReply,
            tooltip: "Volver"
        },
        {
            name: "btnModificarC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => onGuargaActualiza(),
            leyenda: "",
            iclase: faSave,
            tooltip: "Guardar"
        },
    ]

    const columnas = [
        { dataField: 'Id', text: 'Id', hidden: true, },
        { dataField: 'Empresa', text: 'Empresa', hidden: true, },
        {
            dataField: 'Descripcion', text: 'Descripción', csvText: 'Descripcion', sort: true,
            headerStyle: (colum, colIndex) => { return { width: '600px', textAlign: 'left' }; }
        },
        {
            dataField: 'Activo', text: 'Activo', sort: true, width: 350, align: 'center',
            headerStyle: (colum, colIndex) => { return { width: '90px', textAlign: 'center' }; }
        },
        {
            dataField: 'AplicaRebajoTardias', text: 'Aplica Rebajo de Tardías', csvText: 'Aplica Rebajo de Tardias', sort: true, align: 'center',
            headerStyle: (colum, colIndex) => { return { width: '150px', textAlign: 'center' }; }
        },
        {
            dataField: 'PermiteIngresoDescripcion', text: 'Permite Ingreso de Descripción', csvText: 'Permite Ingreso de Descripcion', sort: true, align: 'center',
            headerStyle: (colum, colIndex) => { return { width: '150px', textAlign: 'center' }; }
        },
    ];

    const DatosConst = {
        Id: { value: 0, attributes: { readOnly: true, focus: false, label: 'Id', labelEx: '', } },
        Descripcion: { value: '', attributes: { readOnly: false, focus: true, label: 'Descripción', labelEx: '', maxLength: 100, } },
        Empresa: { value: empresa, attributes: { readOnly: true, focus: false, label: 'Empresa', labelEx: '', } },
        Activo: { value: true, attributes: { readOnly: false, focus: false, label: 'Activo', hidden: "unset", } },
        AplicaRebajoTardias: { value: false, attributes: { readOnly: false, focus: false, label: 'Aplica Rebajo Tardías', hidden: "unset", } },
        PermiteIngresoDescripcion: { value: false, attributes: { readOnly: false, focus: false, label: 'Permite Ingreso Descripción', hidden: "unset", } },
    };

    const [datos, setDatos] = useState(DatosConst);

    useEffect(() => {
        muestraArbolEmpleados(false);
        const carga = async () => {
            await cargarDatos()
        }
        carga()
    }, [])

    const selectRow = {
        mode: 'radio',
        clickToSelect: true,
        hideSelectColumn: true,
        onSelect: (row, isSelected) => onRowSelect(row, isSelected),
        bgColor: '#10a599',
        clickToEdit: true,
    };

    const onRowSelect = (row, isSelected) => {
        setID(row.Id);
        setFila(row);
        onRellenaDatos(row);
    }

    const rowEventsDist = {
        onClick: (e, row) => {
        }
    };

    const onActionResultModal = (pValido) => {
        if (pValido) {
            let _OpcionNom = opcionValidarNombre;
            setShowModalSeguridad(false);
            setOpcionValidar(0);
            setOpcionValidarNombre('');
            const _optSegopt = optSeg.TOpciones_Menu;
            switch (_OpcionNom) {
                case _optSegopt.Eliminar.value:
                    onDelete();
                    break;
                case _optSegopt.Editar.value:
                    handleModalNuevoEdita(true);
                    break;
                case _optSegopt.Nuevo.value:
                    handleModalNuevoEdita(false);
                    break;
                default:
                    break;
            }
        }
    }

    const handleCerrarModal = () => setShowModalSeguridad(false);

    const volverAtras = () => {
        historyMenu.push(SiteRutas.Empleados);
    }

    const spinnerModalMostrar = (pSpinnerModal, pSpinnerLabel, pSpinnerTipo) => {
        setSpinnerModal(pSpinnerModal);
        setSpinnerLabel(pSpinnerLabel);
        setSpinnerTipo(pSpinnerTipo);
    }

    const cargarMenuNombre = async (pModulo, pMenuNombre) => {
        try {
            let listMON = await Obtener_MenuNombre_Request(token, pModulo, pMenuNombre);
            if (listMON.Exitoso == false) {
                manageError(listMON, props, '');
                return null;
            }
            return listMON.Datos;
        }
        catch (err) {
            Notificacion.error(`Error: cargarMenuNombre`);
        }
    }

    const cargarMenuOpciones = async (pModuloId, pUsuarioId, pMenuId) => {
        try {

            let listMO = await Obtener_MenuOpciones_Lista_Request(token, pModuloId, pUsuarioId, pMenuId);
            if (listMO.Exitoso === false) {
                manageError(listMO, props, '');
                return null;
            }
            return listMO.Datos;
        }
        catch (err) {
            Notificacion.error(`Error: cargarMenuOpciones`);
        }
    }

    const cargarDatos = async () => {
        let spinnerLabel = 'Cargando datos...';
        spinnerModalMostrar(true, spinnerLabel, 3);

        const _MenuNomb = await cargarMenuNombre(Config.Modulo, optSeg.TMenuSistema.mantenimientoJustificaciones.value);

        let _menuId = 0;

        if (_MenuNomb.ID != undefined) {
            _menuId = _MenuNomb.ID;
        }
        const _UsuarioS = usuarioS;
        let _menuOpciones = null;

        if (_menuId > 0) {
            _menuOpciones = await cargarMenuOpciones(Config.Modulo, _UsuarioS, _menuId);
        }

        setMenuId(_menuId);
        setMenuOpciones(_menuOpciones);

        const response = await GetListaJustificaciones(token, empresa);

        if (response.Exitoso) {
            if (response.Datos.length >= 0) {
                if (response.Datos.length === 1) {
                    if (response.Datos[0].MsgError === "No hay datos por mostrar") {
                        setListJustificaciones([]);
                    }
                    else {
                        setListJustificaciones(response.Datos);
                    }
                }
                else {
                    if (response.Datos.length === 0) {
                        setListJustificaciones([]);
                    }
                    else {
                        setListJustificaciones(response.Datos);
                    }
                }
            }
            else {
                setListJustificaciones([]);
            }
        }
        else {
            const _login = manageError(response, props, '');
            if (_login) {
                spinnerModalMostrar(false, '', 3);
                return;
            };
        }
        spinnerModalMostrar(false, '', 3);
    }

    const onBorrar = async () => {
        const optSegopt = optSeg.TOpciones_Menu;
        const _value = optSegopt.Eliminar.value;
        let validar = validarMenuOpcion(_value);
        if (!validar) {
            await onDelete();
        }
    }

    const onModificaNuevo = async (param) => {
        const optSegopt = optSeg.TOpciones_Menu;
        let _value = "";
        if (param === "Nuevo") {
            _value = optSegopt.Nuevo.value;
            setFila([]);
            onRellenaDatos([]);
        }
        else {
            if (param === "Edita") {
                _value = optSegopt.Editar.value;
                if (!fila || fila.length === 0) {
                    Notificacion.warning('Debe seleccionar un registro.');
                    return;
                }
            }
            else {
                Notificacion.warning('Opción inválida');
                return;
            }
        }

        let validar = validarMenuOpcion(_value);
        if (!validar) {
            await handleModalNuevoEdita(_value === "Nuevo" ? false : true);
        }
    }

    const handleModalNuevoEdita = (param) => {
        setmodoEdicion(param);
        setSelectModal(true);
    }

    const validarMenuOpcion = (pOpcion) => {
        let validar = false;
        let _menuOpciones = menuOpciones;
        const optSegopt = optSeg.TOpciones_Menu;
        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 cerraModalEdicionNuevo = () => { setSelectModal(false); }

    const onRellenaDatos = (fila) => {
        if (fila.Descripcion) {
            let DatosConst = {
                Id: { value: fila.Id, attributes: { readOnly: true, focus: false, label: 'Id', labelEx: '', } },
                Descripcion: { value: fila.Descripcion, attributes: { readOnly: false, focus: true, label: 'Descripción', labelEx: '', maxLength: 100, } },
                Empresa: { value: fila.Empresa, attributes: { readOnly: true, focus: false, label: 'Empresa', labelEx: '', } },
                Activo: { value: fila.Activo === 'Si' ? true : false, attributes: { readOnly: false, focus: false, label: 'Activo', labelEx: '', } },
                AplicaRebajoTardias: { value: fila.AplicaRebajoTardias === 'Si' ? true : false, attributes: { readOnly: false, focus: false, label: 'Aplica Rebajo Tardías', labelEx: '', } },
                PermiteIngresoDescripcion: { value: fila.PermiteIngresoDescripcion === 'Si' ? true : false, attributes: { readOnly: false, focus: false, label: 'Permite Ingreso Descripción', labelEx: '', } },
            };
            setDatos(DatosConst);
        }
        else {
            let DatosConst = {
                Id: { value: 0, attributes: { readOnly: true, focus: false, label: 'Id', labelEx: '', } },
                Descripcion: { value: '', attributes: { readOnly: false, focus: true, label: 'Descripción', labelEx: '', maxLength: 100, } },
                Empresa: { value: empresa, attributes: { readOnly: true, focus: false, label: 'Empresa', labelEx: '', } },
                Activo: { value: true, attributes: { readOnly: false, focus: false, label: 'Activo', labelEx: '', } },
                AplicaRebajoTardias: { value: false, attributes: { readOnly: false, focus: false, label: 'Aplica Rebajo Tardías', labelEx: '', } },
                PermiteIngresoDescripcion: { value: false, attributes: { readOnly: false, focus: false, label: 'Permite Ingreso Descripción', labelEx: '', } },
            };
            setDatos(DatosConst);
        }
    }

    const onChangeDescrip = (e) => {
        const name = e.target.name;
        const value = e.target.value;
        let valido = false;

        let newAttributes = datos[name].attributes;
        const Datos = Object.assign({}, datos, { [name]: { value: value, attributes: newAttributes } })
        setDatos(Datos);
    }

    const handleCheckedChange = (e) => {
        const name = e.target.name;
        const value = e.target.checked;

        let newAttributes = datos[name].attributes;

        const _Datos = Object.assign({}, datos, {
            [name]: {
                value: value,
                attributes: newAttributes,
                id: name,
                name: name,
            },
        });
        setDatos(_Datos);
    }

    const onGuargaActualiza = async () => {

        let modeloDatos = {
            Id: datos.Id.value,
            Descripcion: datos.Descripcion.value,
            Empresa: datos.Empresa.value,
            Activo: datos.Activo.value ? 1 : 0,
            AplicaRebajoTardias: datos.AplicaRebajoTardias.value ? 1 : 0,
            PermiteIngresoDescripcion: datos.PermiteIngresoDescripcion.value ? 1 : 0,
        }

        const response = await MantenimientoJustificaciones_Guardar(token, modeloDatos);

        if (response.Exitoso) {
            setID(0);
            setFila([]);
            cerraModalEdicionNuevo();
            Notificacion.success(`Se actualizó la información con éxito.`);
            await cargarDatos();
        } else {
            Notificacion.error(`Hubo un error al guardar los Rangos. Error : ${response.message}`);
        }
    }

    const onDelete = async () => {

        let resultado = false;

        if (validaSeleccionado()) {

            Swal.fire({
                title: 'Mantenimiento de Justificaciones',
                html: '<h4>¿Está seguro que desea eliminar la Justificación?</h4>',
                type: 'question',
                showCancelButton: true,
                confirmButtonColor: '#10a599',
                cancelButtonColor: '#d33',
                confirmButtonText: '<h5><i className="fa fa-check fa-fw"></i> Sí</h5>',
                cancelButtonText: '<h5><i className="fa fa-remove fa-fw"></i> No</h5>',
                reverseButtons: true,
                allowOutsideClick: false,
            }).then((result) => {
                if (result.value) {
                    resultado = true;
                    borrarDatos();
                } else if (result.dismiss === Swal.DismissReason.cancel) {
                    resultado = false;
                }
            })
            setBorrando(false);
        }

        setBorrando(false);

        const borrarDatos = async () => {
            spinnerModalMostrar(true, 'Eliminando', 3);
            let resultado = await MantenimientoJustificaciones_Delete(token, empresa, id);
            if (resultado.Exitoso) {
                Notificacion.success(`Se eliminó con éxito.`);
                await cargarDatos();
                setBorrando(true);
                setID(0);
                setFila([]);
            }
            else {
                const _login = manageError(resultado, props, 'Error: ');
                if (_login) {
                    spinnerModalMostrar(false, '', 3);
                    return;
                };
            }
            spinnerModalMostrar(false, '', 3);
        }

        return resultado;
    }

    const validaSeleccionado = () => {
        let _id = id;
        if (_id !== 0) {
            return true;
        }
        else {
            Notificacion.error('Debe seleccionar un registro');
            return false;
        }
    }

    return (
        <>
            <MantenimientoJustificacionesInt
                Titulo={"Mantenimiento de Justificaciones"}
                botones={botones}
                datos={listJustificaciones}
                rowEventsDist={rowEventsDist}
                columnas={columnas}
                selectRow={selectRow}
                nombreCSV={"Justificaciones"}
            />
            <ModalJustificacionNuevoEdita
                Titulo={`Mantenimiento de Justificaciones - ${modoEdicion ? `Editanto` : `Nuevo`}`}
                show={selectModal}
                cerrarModal={cerraModalEdicionNuevo}
                datos={fila}
                modo={modoEdicion}
                botones={botonesMod}
                modelo={datos}
                onChangeDescrip={onChangeDescrip}
                handleCheckedChange={handleCheckedChange}
            />
            <ModalSpinner
                selectedModal={spinnerModal}
                contentLabel={'spinnerModalProgress'}
                label={spinnerLabel}
                tipoSpinner={spinnerTipo}
            />
            <ModalSeguridad
                modalTitle={'Requiere Permisos'}
                menuId={menuId}
                opcionId={opcionValidar}
                show={showModalSeguridad}
                onActionResult={onActionResultModal}
                onHide={handleCerrarModal}
                {...props}
            />
        </>
    )
}

export default withRouter(memo(mantenimientoJustificaciones))
