import React, { Fragment, memo, useEffect, useState, useRef } from 'react';
import { useHistory, withRouter } from 'react-router-dom';

import { farmatearFechaEstandarHora, farmatearFechaEstandar, addDays, farmatearMontos, fechaPrimerDia, fechaUltimoDia, listaRangoNumeros, itemSelect, validarInt, Round, validaCuenta, multiFilter } from '../../../components/Util/Util.jsx';
import Config from '../../../components/Util/constantes.js';
import { SiteRutas } from '../../../request/RutasConfig.jsx';

import ImportarDeExcelInt from './importarDeExcelInt.jsx';
import BotonArriba from '../../../components/UI/botonArriba/botonArriba.jsx';
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
import { faCheck, faReply, faDownload } 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 Swal from 'sweetalert2';

import {
    TipoAsiento_Listar_Request, EncabezadoAsiento_ModificarDesdeExcel_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 { Catalogo_Lista_Request, CentroCosto_Lista_CCC_Request, CentroCosto_Lista_CXCC_Request, CentroCosto_Lista_CXCCEmpresa_Request, CentroCostos_CentroDefault_Request } from "../../../request/ServicioRequest.jsx";
import ModalSeguridad from "../../Seguridad/ModalSeguridad.jsx";
import optSeg from '../../../components/Util/seg-menu-opciones.js';
import moment from 'moment';

import * as XLSX from "xlsx";
import { Type } from 'react-bootstrap-table2-editor';

function ImportarDeExcel(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: true, 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 } },
        Descripcion: { value: "", attributes: { readOnly: true, focus: false, label: 'Descripción', hidden: "unset", maxLength: 510 } },
        Tipo: { value: "", attributes: { readOnly: true, focus: false, label: 'Tipo', hidden: "unset", } },
    });
    const [spinnerModal, setSpinnerModal] = useState(undefined);
    const [spinnerLabel, setSpinnerLabel] = useState('');
    const [spinnerTipo, setSpinnerTipo] = useState(1);

    //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('');

    //datos del formulario
    const [selectedTipo, setSelectedTipo] = useState(null);
    const [listaTipo, setListaTipo] = useState([]);
    const [listaDatos, setListaDatos] = useState([]);
    const [listaCuentas, setListaCuentas] = useState([]);
    const [listCCosto, setListCCosto] = useState([]);
    const [listCXCC, setListCXCC] = useState([]);
    const [id, setId] = useState(0);

    const hiddenFileInput = React.useRef(null);
    const columnas = [
        { dataField: 'Linea', text: '', csvText: '', sort: false, footer: '', hidden: true }
        , {
            dataField: 'CuentaStr', text: 'Cuenta', csvText: 'Cuenta', sort: true, footer: '',
            editable: true,
        },
        { dataField: 'NombreCuenta', text: 'Nombre', sort: true, editable: true, footer: '', },
        { dataField: 'Centro_Costo', text: 'Centro Costo', hidden: true, csvExport: false, sort: true, editable: false, footer: '', },
        {
            dataField: 'Centro_CostoStr', text: 'Centro Costo', csvExport: false, sort: true, editable: true, footer: '',
        },
        {
            dataField: 'Fecha', text: 'Fecha', sort: true, align: 'center', headerAlign: 'center', editable: true, footer: '',
            formatter: (row, cell) => { return cell.Fecha !== '' ? farmatearFechaEstandar(cell.Fecha) : '' },
            editor: {
                type: Type.DATE
            }
        },
        {
            dataField: 'Documento', text: 'Documento', csvText: 'Documento', editable: true, sort: true, align: 'left', headerAlign: 'center', footer: '',
            editor: { type: Type.TEXTAREA },
            validator: (newValue, row, column) => {
                if (newValue.length > 255) {
                    return {
                        valid: false,
                        message: '¡No puede superar los 255 caracteres!'
                    }
                } else {
                    return true;
                }
            },
        },
        {
            dataField: 'Referencia', text: 'Descripción', csvText: 'Referencia', sort: true, align: 'left',
            headerAlign: 'left', editable: true, editor: { type: Type.TEXTAREA },
            validator: (newValue, row, column) => {
                if (newValue.length > 510) {
                    return {
                        valid: false,
                        message: '¡No puede superar los 510 caracteres!'
                    }
                } else {
                    return true;
                }
            },
        },
        {
            dataField: 'Debe', text: 'Debe', csvText: 'Debe',
            formatter: (row, cell) => farmatearMontos(cell.Debe), hidden: false, editable: true, align: 'right',
            validator: (newValue, row, column) => {
                return validaDebe(newValue, row);
            },
            type: 'number'
        },
        {
            dataField: 'Haber', text: 'Haber', csvText: 'Haber', hidden: false, editable: true, align: 'right',
            formatter: (row, cell) => farmatearMontos(cell.Haber), type: 'number',
            validator: (newValue, row, column) => {
                return validaHaber(newValue, row);
            },
        },
        { dataField: 'MsgError', text: 'Error', csvText: 'Error', sort: false, footer: '', hidden: false, csvExport: true }
    ];

    const botones = [
        {
            name: "btnHomeC",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => volverAtras(),
            leyenda: "",
            iclase: faReply,
            tooltip: "Volver"
        },
        {
            name: "btnUtilizar",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: () => handleAceptar(listaDatos),
            leyenda: "",
            iclase: faCheck,
            tooltip: "Utilizar"
        },
        {
            name: "btnImportarExcel",
            clase: "btn btn-sm pull-right flipInX animated",
            evento: (e) => handleClick(e),
            leyenda: "",
            iclase: faDownload,
            tooltip: "Cargar Asiento"
        },
    ];

    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;
        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 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.ImportarExcel.value:
                    handleUtilizarSel();
                    break;
                default:
                    break;
            }
        }
    };

    useEffect(() => {

        const carga = async () => {
            await cargarDatos();
        }
        carga();

    }, []);

    const cargarDatos = async () => {

        try {

            let spinnerLabel = 'Cargando datos...';
            spinnerModalMostrar(true, spinnerLabel, 3);

            const _datosEmpresa = await cargarEmpresa();
            const _Datos = { ...Datos };

            const _id = parseInt(props.match.params.id);

            setId(_id);

            _Datos.fecMesAno.value = moment(_datosEmpresa.Periodo).toDate();

            setDatos(_Datos);

            setDatosEmpresa(_datosEmpresa);

            await cargarTiposAsiento();
            await cargarListaCuentas();
            await cargarCentrosDeCosto();

            const _MenuNomb = await cargarMenuNombre(Config.Modulo, optSeg.TMenuSistema.Asientos.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);

        } catch (e) {
            Notificacion.error(e.message);
        }
        finally {
            spinnerModalMostrar(false, '', 3);
        }
    };

    const cargarListaCuentas = async () => {

        const response = await Catalogo_Lista_Request(token, empresa, 0);
        let _listCuentas = [];
        if (response.Exitoso) {
            _listCuentas = response.Datos;
            setListaCuentas(_listCuentas);
        }
        else {
            Notificacion.error(`Error: ${response.Mensaje}`);
            volverAtras();
        }

        return _listCuentas;

    }

    const cargarCentrosDeCosto = async () => {

        let response = await CentroCosto_Lista_CCC_Request(token, empresa);

        if (response.Exitoso) {
            if (Array.isArray(response.Datos)) {
                setListCCosto(response.Datos);
            } else {
                Notificacion.error('No hay datos para: Centros de Costo.');
                volverAtras();
            }
        }
        else {
            Notificacion.error(response.Mensaje);
            volverAtras();
        }

        response = await CentroCosto_Lista_CXCCEmpresa_Request(token, empresa);

        if (response.Exitoso) {
            if (Array.isArray(response.Datos)) {
                setListCXCC(response.Datos);
            } else {
                Notificacion.error('No hay datos para: Centros de Costo.');
                volverAtras();
            }
        }
        else {
            Notificacion.error(response.Mensaje);
            volverAtras();
        }

    }

    const volverAtras = () => {
        historyMenu.push(SiteRutas.Asientos);
    }

    const validaDebe = (newValue, row) => {
        if (!isNaN(newValue)) {
            if (parseFloat(newValue) > 0 && parseFloat(row.Haber) == 0) {
                return true;
            } else if (parseFloat(newValue) > 0 && parseFloat(row.Haber) > 0) {
                return {
                    valid: false,
                    message: '¡No puede llenar Debe y Haber en la misma fila!'
                }
            } else {
                if (parseFloat(newValue) >= 0) {
                    return true;
                } else {
                    return {
                        valid: false,
                        message: '¡Debe ingresar un valor numérico!'
                    }
                }
            }
        } else {
            return {
                valid: false,
                message: '¡Debe ingresar un valor numérico!'
            }
        }
    }

    const validaHaber = (newValue, row) => {
        if (!isNaN(newValue)) {
            if (parseFloat(newValue) > 0 && parseFloat(row.Debe) == 0) {
                return true;
            } else if (parseFloat(newValue) > 0 && parseFloat(row.Debe) > 0) {
                return {
                    valid: false,
                    message: '¡No puede llenar Debe y Haber en la misma fila!'
                }
            } else {
                if (parseFloat(newValue) >= 0) {
                    return true;
                } else {
                    return {
                        valid: false,
                        message: '¡Debe ingresar un valor numérico!'
                    }
                }
            }
        } else {
            return {
                valid: false,
                message: '¡Debe ingresar un valor numérico!'
            }
        }
    }

    const cellEdit = { mode: 'click', blurToSave: true, autoSelectText: true };

    const selectRow = {
        mode: 'radio', hideSelectColumn: true, bgColor: '#d73220',
        style: { color: '#ffffff' }, clickToSelect: true,
        onSelect: (row, isSelected) => onRowSelect(row, isSelected)
    };

    const onRowSelect = (row, isSelect) => {

        return true;
    }

    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 validaGuardarFila = (fila) => {

        let msgError = "";

        if (fila.Fecha !== null && moment(fila.Fecha).format("YYYY/MM/DD") === moment('1000/01/01').format("YYYY/MM/DD")) {
            msgError = `La fecha digitada es inválida`;
        }

        if (fila.Documento.length > 255) {
            msgError = `El largo del documento es mayor a lo permitido`;
        }

        if (fila.Referencia.length > 255) {
            msgError = `El largo de la referencia es mayor a lo permitido`;
        }

        if (isNaN(fila.Debe)) {
            msgError = `El Monto de débitos no es númerico`;
        }

        if (fila.Debe < 0) {
            msgError = `Los débitos no pueden ser negativos`;
        }

        if (isNaN(fila.Haber)) {
            msgError = `El Monto de créditos no es númerico`;
        }

        if (fila.Haber < 0) {
            msgError = `Los créditos no pueden ser negativos`;
        }

        if ((fila.Debe === fila.Haber) || (fila.Debe === 0 && fila.Haber === 0) || (fila.Debe !== 0 && fila.Haber !== 0)) {
            msgError = `Una de las columnas debe ser cero y la otra un monto correcto`;
        }

        return msgError;

    }

    const validaLista = (_listaDatos) => {

        let valido = true;

        for (let i = 0; i < _listaDatos.length; i++) {

            if (!validaGuardarFila(_listaDatos[i])) {
                valido = false;
                break;
            }

        };

        return valido;

    }

    const handleAceptar = (_listaDatos) => {

        const optSegopt = optSeg.TOpciones_Menu;
        let opcionValidar = optSegopt.ImportarExcel.value;

        try {

            if (id > 0) {

                if (_listaDatos.filter(x => (x.MsgError === null ? '' : x.MsgError).length > 0).length === 0) {
                    if (_listaDatos.filter(x => parseFloat(x.Debe) > 0 || parseFloat(x.Haber) > 0).length > 0) {

                        let validar = validarMenuOpcion(opcionValidar);

                        if (!validar) {
                            handleUtilizarSel();
                        }

                    } else {
                        Notificacion.warning(`Debe seleccionar un Archivo con datos válidos para poder importarlos.`);
                    }
                } else {
                    Notificacion.warning(`Existen errores en las líneas a procesar.`);
                }
            } else {
                Notificacion.warning(`Debe seleccionar un asiento para poder importar un archivo.`);
            }
        } catch (ex) {
            Notificacion.error(`Error: ${ex.message}`);
        }

    }

    const handleUtilizarSel = () => {

        let resultado = false;

        Swal.fire({
            title: 'Importar',
            html: '<h4>¿Está seguro de reemplazar el asiento seleccionado con el contenido del excel? este proceso no se podrá reversar. ¿Desea continuar?',
            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;
                Utilizar();
            } else if (result.dismiss === Swal.DismissReason.cancel) {
                resultado = false;
            }
        });

    }

    const sum = (list, key) => {
        return list.reduce((a, b) => a + (b[key] || 0), 0);
    }

    const Utilizar = async () => {
        try {
            //Tipo Creacion Desde Excel
            const tipoCreacion = 3;

            const tipoAsiento = selectedTipo.value;

            const _datos = {
                Fecha: new Date(), Numero: 0, Descripcion: Datos.Descripcion.value, TipoCreacion: tipoCreacion,
                Debitos: 0, Creditos: 0, DigitadoX: usuario, Estado: 0,
                Usuario_Modifica: usuario, Utilizado: false, id: id, Tipo: tipoAsiento, empresa: empresa,
                Modificado: usuario
            };

            _datos.Debitos = sum(listaDatos, 'Debe');
            _datos.Creditos = sum(listaDatos, 'Haber');

            spinnerModalMostrar(true, `Actualizando Asiento`, 3);
            const response = await EncabezadoAsiento_ModificarDesdeExcel_Request(token, _datos, listaDatos, usuarioS);
            spinnerModalMostrar(false, '', 3);

            if (response.Exitoso) {
                Notificacion.success(`Proceso realizado satisfactoriamente.`);
                volverAtras();
            } else {
                Notificacion.error(`Error: ${response.Mensaje}`);
            }
        } catch (ex) {
            Notificacion.error(`Error: ${ex.message}`);
        }
    }

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

    }

    const onChangeInput = (e) => {

        const name = e.target.name;
        const value = e.target.value;

        let newAttributes = Datos[name].attributes;
        let _Datos = Object.assign({}, Datos, {
            [name]: { value: value, attributes: newAttributes },
        });

        setDatos(_Datos);

    }

    const handleselectTipo = (selTipo) => {

        setSelectedTipo(selTipo);

    }

    const filaValida = (fila) => {
        let result = false;
        for (let col = 0; col < 8; col++) {

            if (fila[col] !== '') {
                result = true;
            }

        }

        return result;

    }

    const generarItem = () => {

        return {
            Asiento: 0,
            Centro_Costo: 0,
            Centro_CostoStr: "",
            Credito: false,
            Cuenta: 0,
            CuentaStr: "",
            Debe: 0,
            Documento: "",
            Fecha: moment().format("YYYY/MM/DD"),
            Fecha_Actualizacion: moment("1900-01-01").format("YYYY/MM/DD"),
            Haber: 0,
            Linea: 0,
            Monto: 0,
            MsgError: "",
            NombreCuenta: "",
            Referencia: "",
            Referencia2: "",
            TipoDoc: 0,
            llave: ""
        };

    }

    const leerArchivoExcel = (dataParse) => {

        const _Datos = { ...Datos };

        try {
            _Datos.Descripcion.value = dataParse[0][1];

            let fila = {};
            let filaRevisa = 3;
            let _listaDatos = [];

            //validamos que el arreglo tenga ocho columnas
            while (dataParse[filaRevisa].length === 8) {

                fila = generarItem();

                fila.Linea = filaRevisa - 2;
                fila.CuentaStr = dataParse[filaRevisa][0];
                fila.Centro_CostoStr = dataParse[filaRevisa][1];
                fila.NombreCuenta = dataParse[filaRevisa][2];
                fila.Fecha = dataParse[filaRevisa][3] == "" ? null : moment(dataParse[filaRevisa][3], "DD/MM/YYYY").toDate();
                fila.Documento = dataParse[filaRevisa][4];
                fila.Referencia = dataParse[filaRevisa][5];

                if (!isNaN(dataParse[filaRevisa][6])) {
                    fila.Debe = parseFloat(dataParse[filaRevisa][6]);
                } else {
                    fila.MsgError = "El Monto de débitos no es númerico";
                }

                if (!isNaN(dataParse[filaRevisa][7])) {
                    fila.Haber = parseFloat(dataParse[filaRevisa][7]);
                } else {
                    fila.MsgError = "El Monto de créditos no es númerico";
                }

                if (!validarCuenta(fila.CuentaStr, filaRevisa)) {
                    break;
                }

                const filtroCuenta = listaCuentas.filter(item => item.Cuenta === fila.CuentaStr.trim());

                if (filtroCuenta.length > 0) {
                    fila.Cuenta = filtroCuenta[0].ID;
                }

                if (!validarCCosto(fila.Cuenta, fila.Centro_CostoStr)) {
                    break;
                }

                const filtroCCosto = listCCosto.filter(item => item.CentroCosto == fila.Centro_CostoStr.trim());

                if (filtroCCosto.length > 0) {
                    fila.Centro_Costo = filtroCCosto[0].ID;
                }

                let tempError = validaGuardarFila(fila);

                if (tempError !== "") {
                    fila.MsgError = tempError;
                }

                _listaDatos.push(fila);

                filaRevisa++;

            }

            setListaDatos(_listaDatos);

            handleAceptar(_listaDatos);

        } catch (ex) {
            console.log(ex);
            Notificacion.error(`Ocurrió un error procesando el archivo.`);
        }
    }

    const cargaArchivoExcel = (e) => {
        e.preventDefault();

        if (e.target.files != undefined) {

            let files = e.target.files, f = files[0];
            let reader = new FileReader();
            let self = this;
            const exts = { '.xls': 1, '.xlsx': 1 };
            let re = /\..+$/;
            let ext = f.name.match(re);
            if (exts[ext]) {
                reader.onload = function (e) {
                    var data = e.target.result;
                    let readedData = XLSX.read(data, { type: 'binary' });
                    const wsname = readedData.SheetNames[0];
                    const ws = readedData.Sheets[wsname];

                    const dataParse = XLSX.utils.sheet_to_json(ws, { header: 1 });

                    leerArchivoExcel(dataParse)

                };
            } else {
                setListaDatosDetalle([]);
                Notificacion.warning('Dede seleccionar un archivo del tipo xls o xlsx.');
                e.value = '';
            }
            reader.readAsBinaryString(f);
        }
        e.target.value = '';
    }

    const handleClick = (e) => {
        e.preventDefault();
        hiddenFileInput.current && hiddenFileInput.current.click();
    }

    const cargarTiposAsiento = async () => {
        if (empresa !== 0) {
            const response = await TipoAsiento_Listar_Request(token, empresa);
            let lista = [];
            if (response.Exitoso) {

                if (Array.isArray(response.Datos) && response.Datos.length > 0) {
                    response.Datos.map(x => (lista.push({ value: x.ID, label: x.Nombre, mensual: x.Mensual })));
                    setListaTipo(lista);
                    setSelectedTipo(lista[0]);
                } else {
                    volverAtras();
                }

            }
            else {
                Notificacion.error(response.Mensaje);
                volverAtras();
            }
            return lista;
        }
    }

    const validaCCosto = (plista, pcuenta, pCCosto, pListaCXCC) => {
        let cCosto = new RegExp('^' + pCCosto + '-', 'i');
        let idCC = -1;
        const listCentroCosto = plista.filter(item => item.CentroCosto == pCCosto);
        if (listCentroCosto.length == 0) {
            return 'El centro de costo no existe'
        }
        else {
            const listaCCosto = plista.filter(item => item.CentroCosto.match(cCosto));
            if (listaCCosto.length > 0) {
                return 'El centro de costo es de mayor'
            }
        }
        idCC = listCentroCosto[0].ID;
        // let filtro = { ID: [pcuenta], CentroCosto: [idCC] };
        // const listaCCCosto = multiFilter(pListaCXCC, filtro)


        // if (listaCCCosto.length == 0) {
        //     return 'No existe relacion entre la cuenta y el centro de costo'
        // }

        return '';
    }

    const validarCCosto = (Cuenta, CCosto) => {


        if (Cuenta !== "") {

            const validacion = validaCCosto(listCCosto, Cuenta, CCosto, listCXCC);
            if (validacion.length > 0) {
                Notificacion.error(validacion);
                return false;
            } else {
                const listaCCosto = listCCosto.filter(item => item.Centro_Costo === CCosto);
                return true;
            }
        } else {
            Notificacion.error('No se encontró el centro de costo.');
            return false;
        };

    }

    const validarCuenta = (Cuenta, Linea) => {

        const validacion = validaCuenta(listaCuentas, Cuenta)

        if (validacion.length > 0) {
            Notificacion.error(`Error: ${validacion}, Línea: ${Linea}.`);
            return false;
        } else {

            const _listaCuenta = listaCuentas.filter(item => item.Cuenta == Cuenta || item.CuentaStr == Cuenta);

            if (_listaCuenta.length > 0) {
                return true;
            }
            else {
                Notificacion.error(`No se encontró la cuenta.`);
                return false;
            }
        }

    }

    return (
        <Fragment>
            <ImportarDeExcelInt
                titulo={"Carga de Asientos"}
                Datos={Datos}
                botones={botones}
                handleselectTipo={handleselectTipo}
                onhandleChangeDate={onhandleChangeDate}
                cargaArchivoExcel={cargaArchivoExcel}
                onChangeInput={onChangeInput}
                selectedTipo={selectedTipo}
                listaTipo={listaTipo}
                listaDatos={listaDatos}
                columnas={columnas}
                cellEdit={cellEdit}
                selectRow={selectRow}
                hiddenFileInput={hiddenFileInput}
            />
            <ModalSpinner
                selectedModal={spinnerModal}
                contentLabel={'spinnerModalProgress'}
                label={spinnerLabel}
                tipoSpinner={spinnerTipo}
            />
            <ModalSeguridad
                modalTitle={'Requiere Permisos'}
                menuId={menuId}
                opcionId={opcionValidar}
                show={showModalSeguridad}
                onActionResult={onActionResultModal}
                onHide={handleCerrarModal}
            />
            <BotonArriba Delay={10} Visible={100} />
        </Fragment>

    );

};

export default withRouter(memo(ImportarDeExcel));