﻿import React, { Fragment, memo, useState, useEffect, } from 'react';
import { useHistory, withRouter } from 'react-router-dom';
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
import { faReply, faPlus, faCheck, faSave, faXRay, faTimes, faSync, faCheckDouble, faSearch } from '@fortawesome/free-solid-svg-icons';
import { SiteRutas } from '../../request/RutasConfig.jsx';
import { textFilter } from 'react-bootstrap-table2-filter';
import DiasAcumuladosporAntiguedadInt from './diasAcumuladosporAntiguedadInt.jsx';
import ModalRangoHorasAntiguedad from './modalRangoHorasAntiguedad.jsx';

import Config from '../../components/Util/constantes.js';
import { Notificacion } from '../../components/Util/Notificacion/Notificacion.jsx';
import { manageError } from '../../components/Util/ManageError.js';
import ModalSpinner from '../../components/UI/modalSpinner/modalSpinner.jsx';
import BotonArriba from '../../components/UI/botonArriba/botonArriba.jsx';
import { useSessionStorage } from '../../components/Util/Hooks/useSessionStorage.jsx';

import { muestraArbolEmpleados, validarDecimal, validarInt } from '../../components/Util/Util.jsx';
import { RangosVacAcum_Listar_Request, RangosVacAcum_Guardar_Request } from "../../request/MantenimientosRequest.jsx";

import Swal from 'sweetalert2';

//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';


function diasAcumuladosporAntiguedad(props) {

    const DatosConst = {
        Desde: { value: '', attributes: { readOnly: true, focus: false } },
        Hasta: { value: '', attributes: { readOnly: false, focus: false } },
        DiasAplicar: { value: '', attributes: { readOnly: false, focus: false } },

    };

    const [datos, setDatos] = useState(DatosConst);
    const [id, setID] = useState('');
    const [token, setToken] = useSessionStorage('token', '');
    const [usuario, setUsuario] = useSessionStorage('usuario');
    const [empresa, setEmpresa] = useSessionStorage('empresa');

    const [listaRango, setListaRango] = useState([]);
    const cellEdit = { mode: 'click', autoSelectText: true, blurToSave: true };
    const selectRow = { mode: 'radio', clickToSelect: true, hideSelectColumn: true, onSelect: (row, isSelected) => onRowSelect(row, isSelected), bgColor: '#10a599', clickToEdit: true };

    const [selectModal, setSelectModal] = useState(false);

    const columnasRango = [
        { dataField: 'Desde', text: 'Desde', hidden: false, sort: false, editable: false },
        {
            dataField: 'Hasta', text: 'Hasta', hidden: false, sort: false, editable: true, validator: (newValue, row, column) => {
                const valido = validaCantidad(newValue, row, true);
                return valido;
            }
        },
        {
            dataField: 'Dias', text: 'Días Aplicar', csvText: 'Dias Aplicar', hidden: false, sort: false, editable: true, validator: (newValue, row, column) => {
                const valido = validaMonto(newValue, row);
                return valido;
            }
        },
        { dataField: 'llave', text: 'llave', hidden: true, sort: false, editable: true, csvExport: false }
    ]

    let historyMenu = useHistory();
    const [spinnerModal, setSpinnerModal] = useState(undefined);
    const [spinnerLabel, setSpinnerLabel] = useState('');
    const [spinnerTipo, setSpinnerTipo] = useState(1);

    const titulo = "Días Acumulados por Antigüedad";


    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: () => agregarRangosHoras(),
            leyenda: "",
            iclase: faPlus,
            tooltip: "Agregar Rango"
        },
        {
            name: "btnNuevoC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => ingresarDatos(),
            leyenda: "",
            iclase: faSave,//"fa fa-plus",
            tooltip: "Guardar"
        },
    ]

    const botonDetHoras = [
        {
            name: "btnAgragarDetPre",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => agregarRangosHoras(),
            leyenda: "",
            iclase: "fa fa-plus",
            tooltip: "Agregar Preaviso"
        }
    ]
    const botonesMod = [
        {
            name: "btnHomeC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => cerrarModal(false),
            leyenda: "",
            iclase: faReply,
            tooltip: "Cancelar"
        },
        {
            name: "btnAplicarDocinc",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => { handleModalInc(); },
            leyenda: "",
            iclase: faCheck,
            tooltip: "Aceptar",
        },
    ]

    //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);
    }

    useEffect(() => {
        muestraArbolEmpleados(false);

        const carga = async () => {
            await cargarDatos()
        }
        carga()
    }, [])



    const validaMonto = (newValue) => {
        if (newValue.toString().trim().length == 0) {
            return {
                valid: false,
                message: 'Debe ingresar un dato válido'
            };
        }
        if (isNaN(newValue)) {
            return {
                valid: false,
                message: 'Debe ingresar un dato válido'
            };
        }
        let isValid = true;
        isValid = validarDecimal(newValue);
        if (isValid == false) {
            return {
                valid: false,
                message: 'Debe ingresar un dato válido'
            };
        }
        return { valid: true, mensaje: '' };

    }


    const validaCantidad = (newValue, row, pHasta) => {
        if (isNaN(newValue)) {
            return {
                valid: false,
                message: 'Debe ingresar un dato válido'
            };
        }
        if (newValue.toString().trim().length == 0) {
            return {
                valid: false,
                message: 'Debe ingresar un dato válido'
            };

        }
        let isValid = true;
        isValid = validarInt(newValue);
        if (isValid == false) {
            return {
                valid: false,
                message: 'Debe ingresar un dato válido'
            };
        }

        if (pHasta) {
            if (row.Desde >= newValue) {
                return {
                    valid: false,
                    message: 'El valor Hasta debe ser mayor al valor Desde.'
                };
            }
        }

        validaTablaMontos(row.llave, newValue);
        return { valid: true, mensaje: '' };

    }


    const validaTablaMontos = (pid, pnewValue) => {

        let lista = [];
        let indice = -1;
        let valor = parseInt(pnewValue);

        lista = [...listaRango];


        lista.filter((item, i) => {
            if (item.llave == pid) {
                indice = i;
            }
        });

        if (indice => 0) {
            if (indice < lista.length - 1) {
                indice = indice + 1;
                for (let j = indice, len = lista.length; j < len; j++) {
                    if (valor > 0) {//(parseInt(lista[j].Desde) <= valor){
                        valor = valor + 1;
                        lista[j].Desde = valor;
                        if (parseInt(lista[j].Hasta) <= valor) {
                            valor = valor + 1;
                            lista[j].Hasta = valor;
                        } else {
                            valor = 0;
                        }
                    }
                }
            }
            setListaRango(lista);
        }
    }

    const onRowSelect = (row, isSelected) => {
        setID(row.id);
    }

    const cargarDatos = async () => {
        let spinnerLabel = 'Cargando datos...';
        spinnerModalMostrar(true, spinnerLabel, 3);
        const _lista = await RangosVacAcum_Listar(token);
        setListaRango(_lista);
        const _MenuNomb = await cargarMenuNombre(Config.Modulo, optSeg.TMenuSistema.DiasAcumuladoporAntiguedad.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 RangosVacAcum_Listar = async (pToken) => {
        let datos = [];
        const response = await RangosVacAcum_Listar_Request(pToken);
        if (response.Exitoso) {
            datos = response.Datos;
        } else {
            const _login = manageError(response, props, 'RangosVacAcum_Listar_Request ');
            spinnerModalMostrar(false, '', 3);
            if (_login) { return false; };
        }
        return datos;
    }


    const volverAtras = () => {
        historyMenu.push(SiteRutas.Empleados);
    }

    const agregarRangosHoras = (event) => {
        handleModal(event);
    }

    const handleModal = (event) => {

        const modal = true;
        let Datos = { ...datos };
        let indice = 0;


        const _listaRango = listaRango;
        if (_listaRango.length > 0) {
            indice = _listaRango.length - 1;
            Datos.Desde.value = parseInt(listaRango[indice].Hasta) + 1;
        } else {
            Datos.Desde.value = 0;
        }

        setDatos(Datos);
        setSelectModal(true);
        console.log(`event: ${JSON.stringify(event)}`)
    }

    const rowEventsDist = {
        onClick: (e, row, rowIndex) => {
        }
    };

    //procesar datos

    const ingresarDatos = async () => {
        const optSegopt = optSeg.TOpciones_Menu;
        const _value = optSegopt.Guardar.value;
        let validar = validarMenuOpcion(_value);
        if (!validar) {
            await ingresarDatosSel();
        }
    }

    const ingresarDatosSel = async () => {

        let resultado = '';
        const listaDatos = listaRango;
        let spinnerLabel = 'Actualizando datos';
        spinnerModalMostrar(true, spinnerLabel, 3);
        resultado = await RangosVacAcum_Guardar_Request(token, JSON.stringify(listaDatos));
        spinnerModalMostrar(false, '', 3)
        if (resultado.Exitoso == true) {
            Notificacion.success('Se actualizó la información con éxito');
        }
        else {
            if (isNaN(resultado.Mensaje.trim())) {
                const _login = manageError(resultado, props, 'Error: -');
                spinnerModalMostrar(false, '', 3);
                if (_login) { return false; };
            }
            else {
                spinnerModalMostrar(false, '', 3)
                Notificacion.success('Se almacenó la información con éxito');
            }
        }

    }
    //Modal

    const onChangeInputInt = (e) => {
        const name = e.target.name;
        const value = e.target.value;
        let valido = false;

        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 onChangeInputDecimal = (e) => {
        const name = e.target.name;
        const value = e.target.value;

        const valido = validarDecimal(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 agregarRangosPre = (event) => {
        handleModal(event);
    }

    const cerrarModal = () => {
        setSelectModal(false);
    }

    const handleModalInc = () => {
        let Datos = { ...datos };
        const mensaje = validarDatos(Datos);
        //let _eventTabla = eventTabla;
        if (mensaje.trim().length == 0) {
            const lista = insertaFilaDato(Datos);
            Datos.Desde.value = 0;
            Datos.Hasta.value = 0;
            Datos.DiasAplicar.value = 0;
            setSelectModal(false);
            setDatos(Datos);
            setListaRango(lista);
            console.log(`handleModalInc lista: ${lista}`);
            //eventTabla('0');
            // eventTabla('');


        }
        else {
            Notificacion.error(`Error: ${mensaje}`);
        }

    }

    const validarDatos = (pDatos) => {

        let mensaje = '';
        if (pDatos.Desde.value.toString().trim().length == 0) { mensaje = ' Desde' }
        if (pDatos.Hasta.value.toString().trim().length == 0) {
            if (mensaje.trim().length == 0) {
                mensaje = ' Hasta'
            } else {
                mensaje = mensaje + ', Hasta'
            }
        }
        if (pDatos.DiasAplicar.value.toString().trim().length == 0) {
            if (mensaje.trim().length == 0) {
                mensaje = ' Días Aplicar'
            } else {
                mensaje = mensaje + ', Días Aplicar'
            }
        }


        if (mensaje.trim().length > 0) {

            mensaje = 'Debe ingresar datos válidos en los siguientes campos:' + mensaje + '.'
            return mensaje;
        }

        if (pDatos.Desde.value >= pDatos.Hasta.value) {
            mensaje = 'El valor Hasta debe ser mayor al valor Desde.'
            return mensaje;
        }

        return mensaje;

    }

    const insertaFilaDato = (pDatos) => {

        let lista = [];
        let tipo = -1;
        let tipostr = 'VA';

        lista = [...listaRango];
        let indice = lista.length.toString() + tipostr;

        let item = { Desde: pDatos.Desde.value, Hasta: pDatos.Hasta.value, Dias: pDatos.DiasAplicar.value, llave: indice };

        lista.push(item);

        return lista;


    }

    //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) => {
        console.log(`onActionResultModal pValido: ${pValido}`)
        if (pValido) {
            let _OpcionNom = opcionValidarNombre;
            setShowModalSeguridad(false); setOpcionValidar(0); setOpcionValidarNombre('');
            const _optSegopt = optSeg.TOpciones_Menu;
            switch (_OpcionNom) {
                case _optSegopt.Guardar.value:
                    ingresarDatosSel();
                    break;
                default:
                    break;
            }
        }
    }

    return (
        <Fragment>
            <div>
                <DiasAcumuladosporAntiguedadInt
                    Titulo={titulo}
                    botonDetHoras={botonDetHoras}
                    botones={botones}
                    listaRango={listaRango}
                    rowEventsDist={rowEventsDist}
                    cellEdit={cellEdit}
                    columnasRango={columnasRango}
                    ingresarDetalle={agregarRangosPre}
                    selectRow={selectRow}
                />
            </div>
            <BotonArriba Delay={10} Visible={100} />
            <ModalRangoHorasAntiguedad
                botonesMod={botonesMod}
                show={selectModal}
                contentLabel={'selectedB'}
                titulo={'Rangos de Antigüedad'}
                onChangeInputInt={onChangeInputInt}
                onChangeInputDecimal={onChangeInputDecimal}
                cerrarModal={cerrarModal}
                //seleccionModal={this.seleccionModal}
                Datos={datos}


            />
            <ModalSpinner
                selectedModal={spinnerModalMostrar.mostrar}
                contentLabel={'spinnerModalProgress'}
                label={spinnerModalMostrar.label}
                tipoSpinner={spinnerModalMostrar.tipo}
            />
            <ModalSeguridad
                //token={this.props.token}
                modalTitle={'Requiere Permisos'}
                menuId={menuId}
                opcionId={opcionValidar}
                show={showModalSeguridad}
                onActionResult={onActionResultModal}
                onHide={handleCerrarModal}
                {...props}
            />
        </Fragment>
    );
};
export default withRouter(memo(diasAcumuladosporAntiguedad));