import React, { Fragment, memo, useEffect, useRef, useState } from 'react';
import { useHistory, withRouter } from 'react-router-dom';
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
import { faReply, faPlus, faPencilAlt, faTrash, faListAlt } from '@fortawesome/free-solid-svg-icons';
import CatalogoCuentasInt from './catalogoCuentasInt.jsx';
import { SiteRutas } from '../../request/RutasConfig.jsx';
import { datosArbol, formatearMesNombreAnno, addMonths, farmatearMontos, fechaUltimoDia } from '../../components/Util/Util.jsx';
//Invocaciones datos
import { CatalogoHist_ListarTablaSaldos_Request, EncabezadoAsientos_Existe_Cuenta_Request } from "../../request/MantenimientosRequest.jsx"
import { Empresa_Consulta_Request } from "../../request/SeguridadRequest.jsx"
import { Catalogo_Lista_Request, Catalogo_ListarTablaSaldos_Request, Catalogo_Eliminar_Request } from "../../request/ServicioRequest.jsx";
import { useSessionStorage } from '../../components/Util/Hooks/useSessionStorage.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';
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';
import { noAuto } from '@fortawesome/fontawesome-svg-core';


export function catalogoCuentas(props) {

	const listaCampos = {
		BotonesAE: { value: 0.0, attributes: { readOnly: false, focus: false, label: '', float: 'right', hidden: 'unset' } },
	}
	const datosNavegador = { value: '', attributes: { hiddenAtras: 'unset', hiddenSig: 'unset' } };
	const [datos, setDatos] = useState(listaCampos);
	let historyMenu = useHistory();
	const [token, setToken] = useSessionStorage('tokenCON', '');
	const [empresa, setEmpresa] = useSessionStorage('empresaCON', 0);
	const [empresaNombreCON, setEmpresaNombreCON] = useSessionStorage('empresaNombreCON', 'ND')
	const [usuario, setUsuario] = useSessionStorage('usuarioCON');
	const mounted = useRef();
	const [spinnerModal, setSpinnerModal] = useState(undefined);
	const [spinnerLabel, setSpinnerLabel] = useState('');
	const [spinnerTipo, setSpinnerTipo] = useState(1);
	const botones = [
		{
			name: "btnHomeC",
			clase: "btn btn-sm pull-right flipInX animated",
			evento: () => volverAtras(),
			leyenda: "",
			iclase: faReply,
			tooltip: "Volver"
		},
		{
			name: "btnModificarC",
			clase: "btn btn-sm pull-right flipInX animated",
			evento: () => actualizarDatos(),
			leyenda: "",
			iclase: faPencilAlt,//"fa fa-pencil",
			tooltip: "Modificar"
		},
		{
			name: "btnNuevoC",
			clase: "btn btn-sm pull-right flipInX animated",
			evento: () => ingresarDatos(),
			leyenda: "",
			iclase: faPlus,//"fa fa-plus",
			tooltip: "Agregar nuevo"
		},
		{
			name: "btnDeleteC",
			clase: "btn btn-sm pull-right flipInX animated",
			evento: () => handleBorrar(),
			leyenda: "",
			iclase: faTrash,
			tooltip: "Eliminar"
		},
	]
	const botonesLista = [
		{
			name: "btnSubTipos",
			clase: "btn btn-sm pull-right flipInX animated",
			evento: () => ingresarSubTipo(),
			leyenda: "Subtipos",
			iclase: null,
			tooltip: "Subtipos"
		},
		{
			name: "btnInsertaMasivo",
			clase: "btn btn-sm pull-right flipInX animated",
			evento: () => ingresarMasivo(),
			leyenda: "Inserta Masivo",
			iclase: null,
			tooltip: "Inserta Masivo"
		},
		{
			name: "btnCentrocosto",
			clase: "btn btn-sm pull-right flipInX animated",
			evento: () => ingresaCentrocosto(),
			leyenda: "Centro Costo",
			iclase: null,
			tooltip: "Centro Costo"
		}
	]

	const [empresaDatos, setEmpresaDatos] = useState([]);

	const [listCuentasCont, setListCuentasCont] = useState([]);
	const [listCuentas, setListCuentas] = useState([])
	const [selectedCuenta, setSelectedCuenta] = useState(undefined);
	const [selectedCuentaTabla, setSelectedCuentaTabla] = useState(undefined);

	const columnasTabla = [{
		dataField: 'ColumnaNombre',
		text: 'Mes',
		csvText: 'Mes',
		sort: false,
		headerStyle: {width:'160px' }
	}, {
		dataField: 'Saldo00',
		text: 'P.Ante',
		csvText: 'P.Ante',
		sort: false,
		align: 'right',
		formatter: (row, cell) => { return farmatearMontos(cell.Saldo00) },
		style: (cell, row, rowIndex, colIndex) => {
			return {
				padding: '8px',
				minWidth: '100px',
			}
		},
		headerStyle: {width:'160px' }
	}, {
		dataField: 'Saldo10',
		text: 'Octubre',
		csvText: 'Octubre',
		sort: false,
		align: 'right',
		formatter: (row, cell) => { return farmatearMontos(cell.Saldo10) },
		style: (cell, row, rowIndex, colIndex) => {
			return {
				padding: '8px',
				minWidth: '100px',
			}
		},
		headerStyle: {width:'160px' }
	}, {
		dataField: 'Saldo11',
		text: 'Noviembre',
		csvText: 'Noviembre',
		sort: false,
		align: 'right',
		formatter: (row, cell) => { return farmatearMontos(cell.Saldo11) },
		style: (cell, row, rowIndex, colIndex) => {
			return {
				padding: '8px',
				minWidth: '100px',
			}
		},
		headerStyle: {width:'160px' }
	}, {
		dataField: 'Saldo12',
		text: 'Diciembre',
		csvText: 'Diciembre',
		sort: false,
		align: 'right',
		formatter: (row, cell) => { return farmatearMontos(cell.Saldo12) },
		style: (cell, row, rowIndex, colIndex) => {
			return {
				padding: '8px',
				minWidth: '100px',
			}
		},
		headerStyle: {width:'160px' }
	}, {
		dataField: 'Saldo01',
		text: 'Enero',
		csvText: 'Enero',
		sort: false,
		align: 'right',
		formatter: (row, cell) => { return farmatearMontos(cell.Saldo01) },
		style: (cell, row, rowIndex, colIndex) => {
			return {
				padding: '8px',
				minWidth: '100px',
			}
		},
		headerStyle: {width:'160px' }
	}, {
		dataField: 'Saldo02',
		text: 'Febrero',
		csvText: 'Febrero',
		sort: false,
		align: 'right',
		formatter: (row, cell) => { return farmatearMontos(cell.Saldo02) },
		style: (cell, row, rowIndex, colIndex) => {
			return {
				padding: '8px',
				minWidth: '100px',
			}
		},
		headerStyle: {width:'160px' }
	}, {
		dataField: 'Saldo03',
		text: 'Marzo',
		csvText: 'Marzo',
		sort: false,
		align: 'right',
		formatter: (row, cell) => { return farmatearMontos(cell.Saldo03) },
		style: (cell, row, rowIndex, colIndex) => {
			return {
				padding: '8px',
				minWidth: '100px',
			}
		},
		headerStyle: {width:'160px' }
	}, {
		dataField: 'Saldo04',
		text: 'Abril',
		csvText: 'Abril',
		sort: false,
		align: 'right',
		formatter: (row, cell) => { return farmatearMontos(cell.Saldo04) },
		style: (cell, row, rowIndex, colIndex) => {
			return {
				padding: '8px',
				minWidth: '100px',
			}
		},
		headerStyle: {width:'160px' }
	}, {
		dataField: 'Saldo05',
		text: 'Mayo',
		csvText: 'Mayo',
		sort: false,
		align: 'right',
		formatter: (row, cell) => { return farmatearMontos(cell.Saldo05) },
		style: (cell, row, rowIndex, colIndex) => {
			return {
				padding: '8px',
				minWidth: '100px',
			}
		},
		headerStyle: {width:'160px' }
	}, {
		dataField: 'Saldo06',
		text: 'Junio',
		csvText: 'Junio',
		sort: false,
		align: 'right',
		formatter: (row, cell) => { return farmatearMontos(cell.Saldo06) },
		style: (cell, row, rowIndex, colIndex) => {
			return {
				padding: '8px',
				minWidth: '100px',
			}
		},
		headerStyle: {width:'160px' }
	}, {
		dataField: 'Saldo07',
		text: 'Julio',
		csvText: 'Julio',
		sort: false,
		align: 'right',
		formatter: (row, cell) => { return farmatearMontos(cell.Saldo07) },
		style: (cell, row, rowIndex, colIndex) => {
			return {
				padding: '8px',
				minWidth: '100px',
			}
		},
		headerStyle: {width:'160px' }
	}, {
		dataField: 'Saldo08',
		text: 'Agosto',
		csvText: 'Agosto',
		sort: false,
		align: 'right',
		formatter: (row, cell) => { return farmatearMontos(cell.Saldo08) },
		style: (cell, row, rowIndex, colIndex) => {
			return {
				padding: '8px',
				minWidth: '100px',
			}
		},
		headerStyle: {width:'160px' }
	}, {
		dataField: 'Saldo09',
		text: 'Setiembre',
		csvText: 'Nombre',
		sort: false,
		align: 'right',
		formatter: (row, cell) => { return farmatearMontos(cell.Saldo09) },
		style: (cell, row, rowIndex, colIndex) => {
			return {
				padding: '8px',
				minWidth: '100px',
			}
		},
		headerStyle: {width:'160px' }
	}, {
		dataField: 'Total',
		text: 'Total',
		csvText: 'Total',
		sort: false,
		align: 'right',
		formatter: (row, cell) => { return farmatearMontos(cell.Total) },
		style: (cell, row, rowIndex, colIndex) => {
			return {
				padding: '8px',
				minWidth: '100px',
			}
		},
		headerStyle: {width:'200px' }
	}, {
		dataField: 'llave',
		text: 'llave',
		sort: false,
		hidden: true,
		editable: false, csvExport: false
	}]
	const selectRowTabla = { mode: 'radio', clickToSelect: false, hideSelectColumn: true };
	const [borrando, setBorrando] = useState(false);

	//tabla saldos
	const [datosNav, setDatosNav] = useState(datosNavegador);
	const [listaDatoSaldo, setListaDatoSaldo] = useState([]);
	const [InicioPeriodo, setInicioPeriodo] = useState(new Date());
	const [FinPeriodo, setFinPeriodo] = useState(new Date());

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

	const spinnerModalMostrar = (pSpinnerModal, pSpinnerLabel, pSpinnerTipo) => {
		setSpinnerModal(pSpinnerModal);
		setSpinnerLabel(pSpinnerLabel);
		setSpinnerTipo(pSpinnerTipo);
	}


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

	const actualizarDatos = async () => {
		if (!!selectedCuenta) {
			if (!selectedCuenta.node.value == 0) {
				const idp = 0;
				const idh = selectedCuenta.node.value;
				const idr = 0;
				//validad que no sea padre
				historyMenu.push(`${SiteRutas.MantCatalogoCuentas}/${idp}/${idh}/${idr}`);
			} else {
				Notificacion.error('Debe seleccionar una cuenta.');
			}

		} else {
			Notificacion.warning(`Debe seleccionar una cuenta.`);
		}

	};
	const ingresarDatos = async () => {
		if (!!selectedCuenta) {
			let idp = selectedCuenta.node.value;
			let idh = 0;
			let idr = (idp == 0) ? '1' : 0; //depende si es la raiz principal del arbol como la empresa		
			if (selectedCuenta.node.children) {
				historyMenu.push(`${SiteRutas.MantCatalogoCuentas}/${idp}/${idh}/${idr}`);

			} else {
				//validar si tiene asientos asociados y si no si puede agrargar
				if (!selectedCuenta.node.children) {
					//validar asientos ligados  EncabezadoAsientos_Existe_Cuenta_Request
					const _ValidoIG = await validadCuentasEnAsientos(empresa, idp);
					if (!_ValidoIG) {
						return false;
					}
					historyMenu.push(`${SiteRutas.MantCatalogoCuentas}/${idp}/${idh}/${idr}`);
				}

			}

		} else {
			Notificacion.warning(`Debe seleccionar una cuenta`);
			return false;
		}
	};



	const handleBorrar = async () => {
		const _Valido = await validaSeleccionado();
		if (_Valido) {
			const optSegopt = optSeg.TOpciones_Menu;
			let validar = validarMenuOpcion(optSegopt.Eliminar.value);
			if (!validar) {
				await handleBorrarSel();
			}
		}
	}


	const handleBorrarSel = async () => {
		let resultado = false;
		const _Valido = await validaSeleccionado();
		if (_Valido) {

			Swal.fire({
				title: 'Eliminar Cuentas',
				html: '<h4>¿Está seguro que desea eliminar la cuenta"?</h4>',
				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;
					borrarDatos();
				} else if (result.dismiss === Swal.DismissReason.cancel) {
					resultado = false;
				}
			})
			setBorrando(false);
		}

		return resultado;
	}


    const borrarDatos = async () => {
        let _id = selectedCuenta.node.value;
        let resultado = '';
        spinnerModalMostrar(true, 'Eliminando', 3);
        resultado = await Catalogo_Eliminar_Request(token,empresa, _id, usuario);
        if (resultado.Exitoso) {
            Notificacion.success(`Se eliminó con éxito.`);
            setBorrando(true);
            await cargarDatos(true);
			setSelectedCuenta(undefined);

        }
        else {
            Notificacion.error(`Error: ${resultado.Mensaje}.`);
       }

        spinnerModalMostrar(false, '', 3);

    }


	const validaSeleccionado = async () => {
		if (selectedCuenta == undefined) {
			Notificacion.error(`Debe seleccionar una cuenta.`);
			return false;
		}
		if (selectedCuenta.node.children) {

			Notificacion.error('La cuenta seleccionada tiene cuentas hijas.');
			return false;
		}
		//validar asientos ligados  EncabezadoAsientos_Existe_Cuenta_Request
		const _ValidoB = await validadCuentasEnAsientos(empresa, selectedCuenta.node.value);
		if (!_ValidoB) {
			return false;
		}
		return true;
	}

	const ingresarSubTipo = () => {
		if (!!selectedCuenta) {
			if (selectedCuenta.node.value > 0) {
				if (selectedCuenta.parentNode.value == 0) {
					const idp = 0;
					const idh = selectedCuenta.node.value;
					const idr = 1;
					historyMenu.push(`${SiteRutas.MantCatalogoCuentas}/${idp}/${idh}/${idr}`);
				} else {
					Notificacion.error('Debe seleccionar una cuenta del nivel 1.');
				}
			} else {
				Notificacion.warning(`Debe seleccionar una cuenta.`);
			}

		} else {
			Notificacion.warning(`Debe seleccionar una cuenta.`);
		}
	}
	const ingresarMasivo = () => {historyMenu.push(SiteRutas.InsertarMasivo)};

	const ingresaCentrocosto = () => {
		if (!!selectedCuenta) {
			if (selectedCuenta.node.value > 0) {
				const id = selectedCuenta.node.value;
				const padre = (!selectedCuenta.node.children)? "0":"1" ;
				historyMenu.push(`${SiteRutas.AsociarCentroCosto}/${id}/${padre}`);
			} else {
				Notificacion.warning('Debe seleccionar una cuenta.');
			}
		} else {
			Notificacion.warning(`Debe seleccionar una cuenta.`);
		}
	};

	const cargarDatos = async () => {
		let spinnerLabel = 'Cargando datos...';
		spinnerModalMostrar(true, spinnerLabel, 3)
		let _id = (props.match.params.id == '0') ? '' : props.match.params.id;

		const _EmpresaDatos = await cargaEmpresa();
		setEmpresaDatos(_EmpresaDatos);
		let _span = datosNav;
		_span.value = datosNavCrear(_EmpresaDatos.InicioPeriodo, _EmpresaDatos.FinPeriodo);
		_span.attributes.hiddenSig = 'none';
		setDatosNav(_span);
		setInicioPeriodo(_EmpresaDatos.InicioPeriodo);
		setFinPeriodo(fechaUltimoDia(new Date(_EmpresaDatos.FinPeriodo)));
		const _ListCuentasCont = await carga_ListTree();
		setListCuentasCont(_ListCuentasCont);

		const _MenuNomb = await cargarMenuNombre(Config.Modulo, optSeg.TMenuSistema.CatalogodeCuentas.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 datosNavCrear = (pInicioPeriodo, pFinPeriodo) => {
		const _Desde = formatearMesNombreAnno(pInicioPeriodo);
		const _Fin = formatearMesNombreAnno(pFinPeriodo);
		return <Fragment><span>{_Desde}</span><span>/</span><span>{_Fin}</span></Fragment>;
	}

	useEffect(() => {

		if (!mounted.current) {
			const carga = async () => {
				await cargarDatos()
			}
			carga();
			mounted.current = true;
		}

	}, [])


	const cargaEmpresa = async () => {

		const response = await Empresa_Consulta_Request(token, empresa);
		if (response.Exitoso) {
			return response.Datos;
		}
		else {
			spinnerModalMostrar(false, '', 3)
			manageError(response, props);
			return [];
		}
	}

	const validadCuentasEnAsientos = async (pEmpresa, pCuenta) => {
		const response = await EncabezadoAsientos_Existe_Cuenta_Request(token, empresa, pCuenta);
		if (response.Exitoso) {
			return true;
		}
		else {
			Notificacion.error(response.Mensaje);
			return false
		}


	}

	const llenadoListaArbol = (pLista) => {
		let _Datos = [];
		const _Lista = pLista;
		const _Empresa = empresaNombreCON;
		//(item.Padres.length > 0 ? parseInt(item.Padres.substring(item.Padres.length - 6, item.Padres.length)) :  0);
		_Datos.push({ "title": _Empresa, "subtitle": "", "padre": -1, "value": 0 });

		_Lista.map(function (item, index) {
			_Datos.push({ "title": item.Cuenta + " " + item.Nombre, "subtitle": "", "padre": (item.Padres.length > 0 ? parseInt(item.Padres.substring(item.Padres.length - 6, item.Padres.length)) : 0), "value": item.ID });
		});

		return _Datos;
	}

	const carga_ListTree = async () => {

		const response = await Catalogo_Lista_Request(token, empresa, 0);
		let _lista = [];
		if (response.Exitoso) {
			const _listCuentas = response.Datos;
			const _listCuentasCont = llenadoListaArbol(_listCuentas);
			setListCuentas(_listCuentas);
			_lista = datosArbol(_listCuentasCont);
		}
		else {
			Notificacion.error(response.Mensaje);
			await volverAtras();
		}

		return _lista;

	}


	const carga_ListTablaSaldo = async (pToken, pEmpresa, pCuenta, pCC) => {
		//setListaDatoSaldo([]);
		const response = await Catalogo_ListarTablaSaldos_Request(pToken, pEmpresa, pCuenta, pCC);
		let _lista = [];
		if (response.Exitoso) {
			const _listaDatoSaldo = response.Datos;
			setListaDatoSaldo(_listaDatoSaldo);
		}
		else {
			Notificacion.error(response.Mensaje);
			//await volverAtras();
		}

		return true;

	}
	const carga_ListTablaSaldoHist = async (pToken, pEmpresa, pCuenta, pCC, pInicioPeriodo, pFinPeriodo) => {
		//setListaDatoSaldo([]);
		const response = await CatalogoHist_ListarTablaSaldos_Request(pToken, pEmpresa, pCuenta, pCC, pInicioPeriodo, pFinPeriodo);
		let _lista = [];
		if (response.Exitoso) {
			const _listaDatoSaldo = response.Datos;
			setListaDatoSaldo(_listaDatoSaldo);
		}
		else {
			Notificacion.error(response.Mensaje);
			//await volverAtras();
		}

		return true;
	}

	const carga_ListaSaldos = async (pToken, pEmpresa, pCuenta, pCC, pInicioPeriodo, pFinPeriodo, pEsMenorP) => {
		setListaDatoSaldo([]);
		if (pEsMenorP) {
			await carga_ListTablaSaldoHist(pToken, pEmpresa, pCuenta, pCC, pInicioPeriodo, pFinPeriodo);
		} else {
			await carga_ListTablaSaldo(pToken, pEmpresa, pCuenta, pCC);
		}

	}
	const onRowSelectBusquedaTree = async (row, id) => {

		if (row.node.value > 0) {
			setSelectedCuenta(row);
			setSelectedCuentaTabla(row);
			const _InicioPeriodo = InicioPeriodo;
			const _FinPeriodo = FinPeriodo;
			const _MenorPer = (new Date(_FinPeriodo) < new Date(empresaDatos.FinPeriodo));

			await carga_ListaSaldos(token, empresa, row.node.value, 0, _InicioPeriodo, _FinPeriodo, _MenorPer);
		} else {
			setSelectedCuenta(row);
			setSelectedCuentaTabla(undefined);
			setListaDatoSaldo([]);
		}
	}

	// tabla de saldos

	const eventoIzquierda = async () => {
		if (!!selectedCuentaTabla) {
			const _InicioPeriodo = addMonths(InicioPeriodo, -12);
			const _FinPeriodo = addMonths(FinPeriodo, -12);
			const _MenorPer = (new Date(_FinPeriodo) < new Date(empresaDatos.FinPeriodo));
			let _span = datosNav;
			_span.value = datosNavCrear(_InicioPeriodo, _FinPeriodo);
			_span.attributes.hiddenSig = (_MenorPer) ? 'unset' : 'none';
			setDatosNav(_span);
			setInicioPeriodo(_InicioPeriodo);
			setFinPeriodo(_FinPeriodo);
			await carga_ListaSaldos(token, empresa, selectedCuentaTabla.node.value, 0, _InicioPeriodo, _FinPeriodo, _MenorPer);
		} else {
			Notificacion.warning('Debe seleccionar una cuenta.');
		}

	}
	const eventoDerecha = async () => {
		if (!!selectedCuentaTabla) {
			const _InicioPeriodo = addMonths(InicioPeriodo, 12);
			const _FinPeriodo = addMonths(FinPeriodo, 12);
			const _MenorPer = (new Date(_FinPeriodo) < new Date(empresaDatos.FinPeriodo));
			let _span = datosNav;
			_span.value = datosNavCrear(_InicioPeriodo, _FinPeriodo);
			_span.attributes.hiddenSig = (_MenorPer) ? 'unset' : 'none';
			setDatosNav(_span);
			setInicioPeriodo(_InicioPeriodo);
			setFinPeriodo(_FinPeriodo);
			await carga_ListaSaldos(token, empresa, selectedCuentaTabla.node.value, 0, _InicioPeriodo, _FinPeriodo, _MenorPer);
		} else {
			Notificacion.warning('Debe seleccionar una cuenta.');
		}
	}

	//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 = async (pValido) => {
		if (pValido) {
			let _OpcionNom = opcionValidarNombre;
			setShowModalSeguridad(false); setOpcionValidar(0); setOpcionValidarNombre('');
			const _optSegopt = optSeg.TOpciones_Menu;
			switch (_OpcionNom) {
				case _optSegopt.Eliminar.value:
					await  handleBorrarSel();
					break;
				default:
					break;
			}
		}
	}


	return (
		<Fragment>
			<CatalogoCuentasInt
				Datos={datos}
				botones={botones}
				botonesLista={botonesLista}
				Titulo={'Catálogo de Cuentas'}
				onRowSelectBusquedaTree={onRowSelectBusquedaTree}
				listCuentasCont={listCuentasCont}
				eventoIzquierda={eventoIzquierda}
				eventoDerecha={eventoDerecha}
				DatosNav={datosNav}
				id={'llave'}
				selectRowTabla={selectRowTabla}
				columnasTabla={columnasTabla}
				ListaDatoSaldo={listaDatoSaldo}
			/>
			<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}
			/>
		</Fragment>
	);
};
export default memo(catalogoCuentas);