import React, { Fragment, memo, useState, useEffect, } from 'react';
import { useHistory, withRouter } from 'react-router-dom';
import { faReply, faSave } from '@fortawesome/free-solid-svg-icons';
import EdicionDepartamentosCuponesInt from './edicionDepartamentosCuponesInt.jsx';
import { useSessionStorage } from '../../../components/Util/Hooks/useSessionStorage.jsx';
import { SiteRutas } from '../../../request/RutasConfig.jsx';
import { Notificacion } from '../../../components/Util/Notificacion/Notificacion.jsx';
import { muestraArbolEmpleados } from '../../../components/Util/Util.jsx';
import { manageError } from '../../../components/Util/ManageError.js';
import { Obtener_MenuNombre_Request, Obtener_MenuOpciones_Lista_Request } from '../../../request/MenuRequest.jsx';
import ModalSeguridad from '../../Seguridad/ModalSeguridad.jsx';
import optSeg from '../../../components/Util/seg-menu-opciones.js';
import Config from '../../../components/Util/constantes.js';
import { Organigrama_ListarAreaDepto_Request } from '../../../request/SeguridadRequest.jsx';
import { CuponDepartamento_Listar_Request, CuponDepartamento_Eliminar_Request, CuponDepartamento_GuardarLista } from '../../../request/MantenimientosRequest.jsx';
import ModalSpinner from '../../../components/UI/modalSpinner/modalSpinner.jsx';

const edicionDepartamentosCupones = (props) => {
    const [usuarioS, setUsuarioS] = useSessionStorage('UsuarioS');
    const [token, setToken] = useSessionStorage('token', '');
    const [empresa, setEmpresa] = useSessionStorage('empresa');
    const [usuario, setUsuario] = useSessionStorage('usuario');
    const [spinnerModal, setSpinnerModal] = useState(undefined);
    const [spinnerLabel, setSpinnerLabel] = useState('');
    const [spinnerTipo, setSpinnerTipo] = useState(1);

    const [listaOrganigramaTree, setListaOrganigramaTree] = useState([]);

    const [idCarga, setIdCarga] = useState([]);
    const [checked, setchecked] = useState([]);
    const [expanded, setexpanded] = useState([]);
    const [menuId, setMenuId] = useState(0);
    const [menuOpciones, setMenuOpciones] = useState([]);
    const [showModalSeguridad, setShowModalSeguridad] = useState(false);
    const [opcionValidar, setOpcionValidar] = useState(0);
    const [opcionValidarNombre, setOpcionValidarNombre] = useState('');

    let historyMenu = useHistory();

    useEffect(() => {
        muestraArbolEmpleados(false);
        const carga = async () => {
            await cargarDatos(false)
        }
        carga()
    }, []);

    const spinnerModalMostrar = (pSpinnerModal, pSpinnerLabel, pSpinnerTipo) => {
        setSpinnerModal(pSpinnerModal);
        setSpinnerLabel(pSpinnerLabel);
        setSpinnerTipo(pSpinnerTipo);
    }

    const cargarDatos = async () => {
        let spinnerLabel = 'Cargando datos...';
        let arrayChecked = [];
        spinnerModalMostrar(true, spinnerLabel, 3)

        let _id = (props.match.params.id == '0') ? '' : props.match.params.id;

        if (_id > 0) {
            setIdCarga(_id);
        } else {
            Notificacion.error("El número de la carga es inválido.");
            volverAtras();
            return;
        }

        const responseDeptos = await CuponDepartamento_Listar_Request(token, empresa, _id);

        if (responseDeptos.Exitoso) {

            let valida = false;

            if (responseDeptos.Datos.length > 1) {
                valida = true;
            } else {
                if (responseDeptos.Datos[0].Empresa !== 0 && responseDeptos.Datos[0].Carga_Id !== 0) {
                    valida = true;
                }
            }

            if (valida) {

                for (let i in responseDeptos.Datos) {
                    arrayChecked.push(`A${responseDeptos.Datos[i].Area}D${responseDeptos.Datos[i].Departamento}`);
                }

            }

        } else {
            Notificacion.error("Sucedió un error al consultar los departamentos de la carga.");
        }

        const _MenuNomb = await cargarMenuNombre(Config.Modulo, optSeg.TMenuSistema.CargaCupones.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 responseOrR = await cargaArbolR();

        let _ArrayDatos = [];
        const nodos = cargaNodeAbiertos(responseOrR, _ArrayDatos);
        setexpanded(nodos);
        setchecked(arrayChecked);
        setListaOrganigramaTree(responseOrR);

        spinnerModalMostrar(false, '', 3)

    };

    const cargaNodeAbiertos = (pDatos, pArray) => {
        let arrayAbierto = pArray;
        for (let j = 0, len = pDatos.length; j < len; j++) {
            pArray.push(`${pDatos[j].id.toString()}`);
            let _arrayD = cargaNodeAbiertos(pDatos[j].children, pArray);
        }
        return pArray;
    };

    const cargaArbolR = async () => {
        //try {

        let responseOr = await Organigrama_ListarAreaDepto_Request(token, empresa);// await organigrama_lista(pEmpresa); 

        if (responseOr.Exitoso) {
            //Notificacion.success("", "Se ha iniciado sesión en empresa lista organigrama.");
        }
        else {
            const _login = manageError(responseOr, props, '');
            if (!_login) { history.push(SiteRutas.Login); }
            return false;

        }
        let _Menu = responseOr.Datos;//.data;
        let _arbolPadre = _Menu.filter(item => item.PadreID === 0);
        let subMenu = [];

        // siempre va tener el home
        let arrayAbierto = [];
        for (let j = 0, len = _arbolPadre.length; j < len; j++) {
            arrayAbierto.push(`${_arbolPadre[j].ID.toString()}`);
            //arrayAbierto.push(`${_arbolPadre[j].ID.toString()}`);
            let _arbolHijo = _Menu.filter(item => item.PadreID === _arbolPadre[j].ID);
            //arma el menu principal
            let _hijo = [];
            //arma los menues hijos
            if (_arbolHijo.length > 0) {
                _hijo = cargaSubArbolR(_arbolHijo, _Menu, _arbolPadre[j].ID, arrayAbierto, _arbolPadre[j].ID.toString());
            }

            subMenu.push({ id: _arbolPadre[j].Composicion, label: _arbolPadre[j].Nombre, isOpen: true, children: _hijo, value: _arbolPadre[j].Composicion });
        };

        //setNodosAbiertos(arrayAbierto);
        return subMenu;
        //  }
        //  catch (err) {

        //  }
    };

    const cargaSubArbolR = (lstSubArbol, lstArbol, pRaiz, pAbierto, pRuta) => {
        let _submenu = [];
        let _hijo = [];

        for (let j = 0, len = lstSubArbol.length; j < len; j++) {
            let _Ruta = `${lstSubArbol[j].ID.toString()}`
            pAbierto.push(_Ruta);
            let _arbolHijo = lstArbol.filter(item => item.PadreID === lstSubArbol[j].ID);
            _submenu = cargaSubArbolR(_arbolHijo, lstArbol, lstSubArbol[j].ID, pAbierto, _Ruta);
            _hijo.push({ id: lstSubArbol[j].Composicion, label: lstSubArbol[j].Nombre, isOpen: true, children: _submenu, value: lstSubArbol[j].Composicion });
        }

        return _hijo;
    }

    const guardarDepartamentos = async (pCarga_Id) => {

        let listaDeptos = checked;
        let listaDinamica = [];

        for (let i in listaDeptos) {

            let item = elementoNodo();
            let arrayString = (listaDeptos[i].split("D"))

            item.Empresa = empresa;
            item.Carga_Id = pCarga_Id;
            item.Usuario_Modifica = usuario;
            item.Area = arrayString[0].replace("A", "");
            item.Departamento = arrayString[1];

            listaDinamica.push(item);
        }

        let resultado = await CuponDepartamento_GuardarLista(token, listaDinamica);

        if (resultado.Exitoso) {
            return true;
        } else {
            return false;
        }

    };

    const elementoNodo = () => {
        return {
            Empresa: 0,
            Usuario_Modifica: "",
            Carga_Id: 0,
            Area: 0,
            Departamento: 0
        };
    };

    const botones = [
        {
            name: "btnHomeC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => volverAtras(),
            leyenda: "",
            iclase: faReply,
            tooltip: "Volver"
        },
        {
            name: "btnGuardarC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => handleGuardarCupones(),
            leyenda: "",
            iclase: faSave,
            tooltip: "Guardar Departamentos"
        },
    ];

    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 volverAtras = () => {
        historyMenu.push(SiteRutas.CargaCupones);
    }

    const handleGuardarCupones = async () => {
        const optSegopt = optSeg.TOpciones_Menu;
        const _value = optSegopt.EditarDeptos.value;

        let validar = validarMenuOpcion(_value);
        if (!validar) {
            await finalizaEditarDeptos();
        };
    }

    const finalizaEditarDeptos = async () => {

        let spinnerLabel = "Editando Datos...";

        spinnerModalMostrar(true, spinnerLabel, 3);

        const responseElimina = await CuponDepartamento_Eliminar_Request(token, empresa, idCarga);

        if (responseElimina.Exitoso) {

            if (checked.length > 0) {
                //Inserta
                let deptos = await guardarDepartamentos(idCarga);

                if (deptos) {
                    Notificacion.success("Se editaron los departamentos de la carga correctamente.");
                    volverAtras();
                } else {
                    //borrar encabezado y cupones
                    Notificacion.error("Sucedió un error al agregar los departamentos.");
                    volverAtras();
                }
            } else {
                Notificacion.success("Se editaron los departamentos de la carga correctamente.");
                volverAtras();
            }

        } else {
            Notificacion.error("Sucedió un error al editar los departamentos de la carga.");
        }

        spinnerModalMostrar(false, '', 3);

    };

    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 handleSetChecked = (pCheck, targetNode) => {
        setchecked(pCheck);
    }

    const changeExpanded = (pCheck) => {
        setexpanded(pCheck);
    }

    const onActionResultModal = (pValido) => {
        if (pValido) {
            let _OpcionNom = opcionValidarNombre;
            setShowModalSeguridad(false); setOpcionValidar(0); setOpcionValidarNombre('');
            const _optSegopt = optSeg.TOpciones_Menu;
            switch (_OpcionNom) {
                case _optSegopt.EditarDeptos.value:
                    finalizaEditarDeptos();
                    break;
                default:
                    break;
            }
        }
    };

    const handleCerrarModal = () => setShowModalSeguridad(false);

    return (
        <Fragment>
            <EdicionDepartamentosCuponesInt
                titulo={`Carga #${idCarga}: Edición de Departamentos`}
                botones={botones}
                listaOrganigramaTree={listaOrganigramaTree}
                checked={checked}
                expanded={expanded}
                changeExpanded={changeExpanded}
                handleSetChecked={handleSetChecked}
            />

            <ModalSeguridad
                modalTitle={'Requiere Permisos'}
                menuId={menuId}
                opcionId={opcionValidar}
                show={showModalSeguridad}
                onActionResult={onActionResultModal}
                onHide={handleCerrarModal}
                {...props}
            />

            <ModalSpinner
                selectedModal={spinnerModal}
                contentLabel={'selectedDescripcionCarga'}
                label={spinnerLabel}
                tipoSpinner={spinnerTipo}
            />
        </Fragment>

    );
};
export default withRouter(memo(edicionDepartamentosCupones))