﻿import React, { Fragment, memo, useEffect, useState } from 'react';
import { useHistory, withRouter } from 'react-router-dom';
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
import { faReply, faSave } from '@fortawesome/free-solid-svg-icons';
import MantBancoPreguntasInt from './MantBancoPreguntasInt.jsx';
import { SiteRutas } from '../../../request/RutasConfig.jsx';
import { muestraArbolEmpleados, validarInt, validaCorreo, validarDecimal, farmatearMontos } from '../../../components/Util/Util.jsx';
//Invocaciones datos
import { TiposAviso_Lista_Request, BancoPreguntasAvisos_ListaAmbos_Request, BancoPreguntasAvisosLista_Eliminar_Request, BancoPreguntasAvisosLista_Guardar_Request, BancoPreguntas_Consulta_Request, BancoPreguntasUltimoConsecutivo_Consulta_Request, BancoPreguntas_Guardar_Request, BancoPreguntas_Modificar_Request } from "../../../request/MantenimientosRequest.jsx"
import { useSessionStorage } from '../../../components/Util/Hooks/useSessionStorage.jsx';
import { useLocalStorage } from '../../../components/Util/Hooks/useLocalStorage.jsx';
//utilitarios
import { Notificacion } from '../../../components/Util/Notificacion/Notificacion.jsx';
import { manageError } from '../../../components/Util/ManageError.js';
import ModalSpinner from '../../../components/UI/modalSpinner/modalSpinner.jsx';

//Seguridad
import Session from '../../../components/Util/session/index.jsx';
import Config from '../../../components/Util/constantes.js';
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';

export function MantBancoPreguntas(props) {

    let historyMenu = useHistory();
    const [token, setToken] = useSessionStorage('token', '');
    const [usuario, setUsuario] = useSessionStorage('usuario');
    const [codigo, setCodigo] = useState('');
    const [id, setId] = useState('');
    const [empresa, setEmpresa] = useSessionStorage('empresa');
    const [ubicacion, setUbicacion] = useLocalStorage('Ubicacion', null);
    const [spinnerModal, setSpinnerModal] = useState(undefined);
    const [spinnerLabel, setSpinnerLabel] = useState('');
    const [spinnerTipo, setSpinnerTipo] = useState(1);



    const columnasTabla = [
        { dataField: 'TipoAviso_Codigo', text: 'Id', csvText: 'Id', hidden: true, sort: true, editable: false },
        { dataField: 'TipoAviso_Descripcion', text: 'Tipo de Aviso', csvText: 'TipoAviso', hidden: false, sort: true, editable: false }
    ]
    const [listaGralTabla, setListaGralTabla] = useState([]);
    const [listaGralTablaBorrar, setListaGralTablaBorrar] = useState({});
    const cellEditTabla = { mode: 'click', blurToSave: true, autoSelectText: true };
    const [selectTabla, setSelectTabla] = useState([]);
    const selectRowTabla = { mode: 'checkbox', bgColor: '#10a599', clickToSelect: true, selected: selectTabla, onSelect: (row, isSelect) => onRowSelectDet(row, isSelect), onSelectAll: (isSelect, rows) => handleOnSelectAllDet(isSelect, rows), hideSelectColumn: false };
    const [verLHOCAP, setVerLHOCAP] = useState(false); 
    const [listaAccionesSel, setListaAccionesSel] = useState([]);
    const [listaMarcadosDesdeBD, setListaMarcadosDesdeBD] = useState([]);
    const [docMant, setDocMant] = useState(undefined);
    const [listaDesmarcada, setListaDesmarcada] = useState([]); 


    const botones = [

        {
            name: "btnHomeC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => volverAtras(),
            leyenda: "",
            iclase: faReply,
            tooltip: "Volver"
        },
        {
            name: "btnGuardar",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => ingresarDatos(),
            leyenda: "",
            iclase: faSave,
            tooltip: "Guardar"
        }
    ]

    const listaCampos = {
        Codigo: { value: 0, attributes: { readOnly: true, focus: false, label: 'Número', hidden: 'unset', Editando: false, maxLength: "5" } },
        Descripcion: { value: '', attributes: { readOnly: false, focus: false, label: 'Descripción', hidden: 'unset', maxLength: "255" } },
        Activo: { value: false, attributes: { readOnly: false, focus: false, hidden: 'unset', label: "Activo", } },
        MsgError: { value: ' ', attributes: { readOnly: false, focus: false } }
    }

    const listaMod = {
        "Empresa": "",
        "Id": "",
        "Descripcion": "",
        "Activo": "",
        "Usuario_Modifica": "",
    }
    const [datos, setDatos] = useState(listaCampos);
    const [listaModel, setListaModel] = useState(listaMod);

    //Seguridad
    const [usuarioS, setUsuarioS] = useSessionStorage('UsuarioS');
    const [menuId, setMenuId] = useState(0);
    const [menuOpciones, setMenuOpciones] = useState([]);
    const [showModalSeguridad, setShowModalSeguridad] = useState(false);
    const [opcionValidar, setOpcionValidar] = useState(0);
    const [opcionValidarNombre, setOpcionValidarNombre] = useState('');

    const spinnerModalMostrar = (pSpinnerModal, pSpinnerLabel, pSpinnerTipo) => {
        setSpinnerModal(pSpinnerModal);
        setSpinnerLabel(pSpinnerLabel);
        setSpinnerTipo(pSpinnerTipo);
    }

    //Comentario: Definir la variable para cada uno de los campos
    const llenarListaDatos = () => {
        let _Campos = datos;
        let _Datos = listaModel;

        _Datos.Empresa = empresa;
        _Datos.Id = _Campos.Codigo.value;
        _Datos.Descripcion = _Campos.Descripcion.value;
         _Datos.Activo = _Campos.Activo.value;
        _Datos.Usuario_Modifica = usuario;

        return _Datos;
    }

    const asociarDatos = (pDatos) => {
        let _Campos = listaCampos;
        _Campos.Codigo.value = pDatos.Id;
        _Campos.Descripcion.value = pDatos.Descripcion;
        _Campos.Activo.value = pDatos.Activo;
        _Campos.Codigo.attributes.readOnly = true;
        return _Campos;
    }

    const volverAtras = () => {
        historyMenu.push(SiteRutas.BancoPreguntas);
    }

    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 cargarDatos = async () => {

        let spinnerLabel = 'Cargando datos...';
        spinnerModalMostrar(true, spinnerLabel, 3)
        let _id = (props.match.params.id == '0') ? '' : props.match.params.id;

        if (_id.length > 0) {

            const response = await BancoPreguntas_Consulta_Request(token, _id, empresa);
            if (response.Exitoso) {
                const _datos = asociarDatos(response.Datos);
                setDatos(_datos);
                setCodigo(_id);
            }
            else {
                const _login = manageError(response, props, '');
                spinnerModalMostrar(false, '', 3);
                if (!_login) { volverAtras(); }
                return false;
            }

            await cargaListaGralTabla();
            await MarcarLista(_id);

        } else {
            setDatos(listaCampos);
            setCodigo(_id);
            await cargaListaGralTabla();
        }
        setId(_id);
        const _MenuNomb = await cargarMenuNombre(Config.Modulo, optSeg.TMenuSistema.BancoPreguntas.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)

        spinnerModalMostrar(false, '', 3)
    }

    const cargaListaGralTabla = async () => {
        setVerLHOCAP(false);
        const response = await TiposAviso_Lista_Request(token, empresa);
        
        if (response.Exitoso) {
            setListaAccionesSel([]);
            let _datos = response.Datos;

            if (_datos.length > 0) {
                const datosOrdenados = _datos.sort((a, b) => a.TipoAviso_Descripcion.localeCompare(b.TipoAviso_Descripcion));
                setListaGralTabla(datosOrdenados);
            } else {
                setListaGralTabla([]);
                setVerLHOCAP(false);
            }
        }
        else {
            setVerLHOCAP(false);
            setListaGralTabla([]);
            if (response.Mensaje.trim().length > 0) {
                const _login = manageError(response, props, '');
                if (_login) { spinnerModalMostrar(false, '', 3); return false; };

            }
        }
    }

    const MarcarLista = async (_id) => {
        setVerLHOCAP(false);
        const response = await BancoPreguntasAvisos_ListaAmbos_Request(token, _id, 0, false, empresa);
        setListaAccionesSel([]);
        let _datos = response.Datos;

        if (response.Exitoso) {
            if (_datos.length > 0) {

                const codigosMarcados = _datos.map(x => x.IdTipoAviso); 

                setSelectTabla(codigosMarcados);
                setListaAccionesSel(codigosMarcados);
                setListaMarcadosDesdeBD(codigosMarcados);
            } else {
                //setListaGralTabla([]);
                setVerLHOCAP(false);
                setSelectTabla([]);
                setListaAccionesSel([]);
                setListaMarcadosDesdeBD([]);
            }
        } else {
            //setListaGralTabla([]);
            setVerLHOCAP(false);
            setSelectTabla([]);
            setListaAccionesSel([]);
            setListaMarcadosDesdeBD([]);
            if (response.Mensaje.trim().length > 0) {
                const _login = manageError(response, props, '');
                if (_login) { spinnerModalMostrar(false, '', 3); return false; };
            }
        }
    }

    useEffect(() => {
        muestraArbolEmpleados(false);
        const carga = async () => { await cargarDatos() }
        carga()
    }, [])

    //procesar datos
    const ingresarDatos = async () => {
        if (validarDatos()) {
            const _id = id;
            const optSegopt = optSeg.TOpciones_Menu;
            const _value = (_id > 0) ? optSegopt.Editar.value : optSegopt.Nuevo.value;
            let validar = validarMenuOpcion(_value);
            if (!validar) {
                await ingresarDatosSel();
            }
        }

    }

    const ingresarDatosSel = async () => {
        if (validarDatos()) {

            const _data = llenarListaDatos();
            let resultado = '';
            let spinnerLabel = id.length > 0 ? 'Actualizando datos' : 'Ingresando datos';
            spinnerModalMostrar(true, spinnerLabel, 3)
            if (codigo.length > 0) {
                resultado = await BancoPreguntas_Modificar_Request(token, JSON.stringify(_data));
            }
            else {
                resultado = await BancoPreguntas_Guardar_Request(token, JSON.stringify(_data));
            };
            
            if ((resultado.Exitoso == true) || (resultado.Exitoso == false && resultado.Mensaje == "0")) {

                const idsAEliminar = listaMarcadosDesdeBD.filter(x => !selectTabla.includes(x));
                const idsANuevoInsertar = selectTabla.filter(x => !listaMarcadosDesdeBD.includes(x));
                let _id = (props.match.params.id == '0') ? '' : props.match.params.id;

                if (codigo.length > 0) {

                    if (idsAEliminar.length > 0) {
                        const dataDelete = idsAEliminar.map(id => ({
                            Empresa: empresa,
                            IdPregunta: Number(_id),
                            IdTipoAviso: id
                        }));

                        const deleteRes = await BancoPreguntasAvisosLista_Eliminar_Request(token, JSON.stringify(dataDelete));
                        if (!deleteRes.Exitoso) {
                            Notificacion.error('Error al eliminar registros desmarcados');
                            return;
                        }
                    }

                    if (idsANuevoInsertar.length > 0) {
                        const dataInsert = idsANuevoInsertar.map(id => ({
                            Empresa: empresa,
                            IdPregunta: Number(_id),
                            IdTipoAviso: id
                        }));

                        const insertRes = await BancoPreguntasAvisosLista_Guardar_Request(token, JSON.stringify(dataInsert));
                        if (!insertRes.Exitoso) {
                            Notificacion.error('Error al insertar registros seleccionados');
                            return;
                        }
                    }

                } else {
                    if (idsANuevoInsertar.length > 0) {

                        if (_id == "") {
                            let consecutivo = await BancoPreguntasUltimoConsecutivo_Consulta_Request(token, empresa);
                            _id = String(consecutivo.Datos.Id);
                        }

                        const dataInsert2 = idsANuevoInsertar.map(id => ({
                            Empresa: empresa,
                            IdPregunta: Number(_id),
                            IdTipoAviso: id
                        }));

                        const insertRes2 = await BancoPreguntasAvisosLista_Guardar_Request(token, JSON.stringify(dataInsert2));
                        if (!insertRes2.Exitoso) {
                            Notificacion.error('Error al insertar registros seleccionados');
                            return;
                        }
                    }
                }

                spinnerModalMostrar(false, '', 3);
                Notificacion.success('Se actualizó la información con éxito');
            }
            else {
                if (isNaN(resultado.Mensaje.trim())) {
                    spinnerModalMostrar(false, '', 3);
                    const _login = manageError(resultado, props, 'Error: ');
                    if (_login) { return false; };
                }
                else {
                    spinnerModalMostrar(false, '', 3);
                    Notificacion.success('Se almacenó la información con éxito');
                }
            }
            volverAtras();
        }
    }

    const validarDatos = () => {
        const _datos = datos;

        if (_datos.Descripcion.value.trim().length == 0) {
            Notificacion.error('Error: Debe indicar una ' + _datos.Descripcion.attributes.label + '.');
            return false;
        }
        if (_datos.Descripcion.value.trim().length > 255) {
            Notificacion.error('Error: La cantidad de caracteres de la ' + _datos.Descripcion.attributes.label + ' es mayor a lo permitido (150 caracteres).');
            return false;
        }

        return true;
    }

    const onChangeInputInt = (e) => {

        const name = e.target.name;
        const value = e.target.value;

        const valido = validarInt(value);
        if (valido) {
            let newAttributes = datos[name].attributes;
            // newAttributes.focus = true; //Se asigna foco al componente
            const Datos = Object.assign({}, datos, { [name]: { value: value, attributes: newAttributes } })
            setDatos(Datos);
        }
    }
    const onChangeEditar = (e) => {

        const name = e.target.name;
        //const value = datos[name].value;// e.target.value;
        const value = (datos[name].value.toString().trim().length > 0) ? datos[name].value : 0;// e.target.value;
        let newAttributes = datos[name].attributes;
        const _Editando = !newAttributes.Editando;
        newAttributes.Editando = _Editando;
        const Datos = Object.assign({}, datos, { [name]: { value: value, attributes: newAttributes } })
        if (_Editando) {
            event.target.type = 'text';
            event.target.value = value;
            event.target.setSelectionRange(0, event.target.value.toString().length);
            event.target.type = 'number';
        }
        setDatos(Datos);
        //state.Datos[name].attributes;
    }
    const onFormatoInt = (valor) => {
        return valor;
    }
    const onChangeInput = (e) => {
        const name = e.target.name;
        const value = e.target.value;
        let newAttributes = datos[name].attributes;
        // newAttributes.focus = true; //Se asigna foco al componente
        const Datos = Object.assign({}, datos, { [name]: { value: value, attributes: newAttributes } })
        setDatos(Datos);
    }

    //Seguridad
    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 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 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;
            //Notificacion.error('No existe opción en la seguridad');
        }
        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.Nuevo.value:
                    ingresarDatosSel();
                    break;
                case _optSegopt.Editar.value:
                    ingresarDatosSel();
                    break;
                default:
                    break;
            }
        }
    }

    const rowEventsTabla = {
        onClick: async (e, row, rowIndex) => {
            if (row.Version == 'N') {
                setDetalleVisible('unset');
                const _SelectedOptionEstado = selectedOptionEstado;

                await cargaListaDetalleAp(row.Empleado_id, row.Numero, _SelectedOptionEstado.value)
            } else {
                setDetalleVisible('none');
            }
        }
    }

    const rowStyleTabla = (row, rowIndex) => {
        const style = {};
        //if (row.CorteRealizado === true) {
        //    style.color = '#21aba0';
        //} else {
        //    style.color = '#b0b0b0';
        // }
        return style;
    }

    const onRowSelectDet = (row, isSelect) => {
        let _listaGralTablaBorrar = {};
        let lista = [...listaAccionesSel];
        let _docMant = undefined;
        let _listaTabla = [...selectTabla];
        if (isSelect) {
            _listaGralTablaBorrar = row;
            lista.push(row.TipoAviso_Codigo);
            _docMant = row;
            _listaTabla.push(row.TipoAviso_Codigo);

        } else {
            _listaGralTablaBorrar = {};
            lista = lista.filter(x => x !== row.TipoAviso_Codigo);
            _docMant = undefined;
            _listaTabla = _listaTabla.filter(x => x !== row.TipoAviso_Codigo);
        }

        const idsTotales = listaGralTabla.map(x => x.TipoAviso_Codigo); 
        const idsDesmarcados = idsTotales.filter(x => !_listaTabla.includes(x)); 

        setListaGralTablaBorrar(_listaGralTablaBorrar);
        setListaAccionesSel(lista);
        setDocMant(_docMant);
        setSelectTabla(_listaTabla);
        setListaDesmarcada(idsDesmarcados);

        return true;
    }

    const handleOnSelectAllDet = (isSelect, rows) => {

        if (isSelect) {
            setListaAccionesSel(rows.map(x => x.Numero));
            setSelectTabla(rows.map(r => r.TipoAviso_Codigo));
            return rows.map(x => x.TipoAviso_Codigo);
        } else {
            setListaAccionesSel([]);
            setSelectTabla([])
            return [];
        }

    }

    return (
        <Fragment>
            <MantBancoPreguntasInt
                botones={botones}
                //Verificar el titulo
                Titulo={'Detalle de la Pregunta'}
                Datos={datos}
                onChangeInputInt={onChangeInputInt}
                onChangeEditar={onChangeEditar}
                onFormatoInt={(onFormatoInt)}
                onChangeInput={onChangeInput}
                handleCheckedChange={handleCheckedChange}

                columnasTabla={columnasTabla}
                listaGralTabla={listaGralTabla}
                cellEditTabla={cellEditTabla}
                rowEventsTabla={rowEventsTabla}
                selectRowTabla={selectRowTabla}
                rowStyleTabla={rowStyleTabla}
                verLHOCAP={verLHOCAP}
            />
            <ModalSpinner
                selectedModal={spinnerModal}
                contentLabel={'spinnerModalProgress'}
                label={spinnerLabel}
                tipoSpinner={spinnerTipo}
            />
            <ModalSeguridad
                //token={this.props.token}
                modalTitle={'Requiere Permisos'}
                menuId={menuId}
                opcionId={opcionValidar}
                show={showModalSeguridad}
                onActionResult={onActionResultModal}
                onHide={handleCerrarModal}
                {...props}
            />
        </Fragment>
    );

};
export default withRouter(memo(MantBancoPreguntas))