
import React, { Fragment, memo, useEffect, useState, useRef } from 'react';
import { useHistory, withRouter } from 'react-router-dom';
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
import { faReply, faSave,faCheck } from '@fortawesome/free-solid-svg-icons';
import AumentoRetroactivosInt from './aumentoRetroactivosInt.jsx';
import ModalErrores from './modalErroresSalPuestosRetro.jsx';
import { SiteRutas } from '../../request/RutasConfig.jsx';
import { muestraArbolEmpleados, validarInt, validarDecimal, farmatearMontos, itemSelect, validarPorcentaje, farmatearPorcentaje, validarIntVig, farmatearFechaEstandar } from '../../components/Util/Util.jsx';
//Invocaciones datos
import { Empleados_Lista_Request, Empleados_Listar_Busqueda_Request,ParametrosGenerales_Consulta_Request } from "../../request/MantenimientosRequest.jsx";
import { AumentoRetroActivo_Request,AumentoSalarial_ValidarSalarioSegunPuesto_Request } from "../../request/AccionesRequest.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 ModalBusquedaEmp from '../../components/UI/modalBusqueda/modalBusquedaFiltro.jsx';
import Config from '../../components/Util/constantes.js';
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 aumentoRetroactivos(props) {
  const mounted = useRef();
  let historyMenu = useHistory();
  const [listaTipoAumt, setListaTipoAumt] = useState([{ label: "Porcentual", value: "P" }, { label: "Monto", value: "M" }, { label: "Salario", value: "S" }]);
  const DatosConst = {
    Empleado: { value: '', attributes: { readOnly: true, focus: false, label: 'Empleado', hidden: 'unset', maxLength: "6", Editando: false, readOnlyBoton: true } },
    EmpleadoNombre: { value: '', attributes: { readOnly: true, focus: false, label: 'Nombre', hidden: 'unset', maxLength: "255", Editando: false } },
    TipoAumento: { value: "", attributes: { readOnly: false, focus: false, label: "Tipo de Aumento", hidden: "unset" } },
    Monto: { value: farmatearMontos(0), attributes: { readOnly: false, focus: false, label: listaTipoAumt[0].label, hidden: "unset", } },
    SalBase: { value: farmatearMontos(0), attributes: { readOnly: true, focus: false, label: 'Salario Base', hidden: "unset", } },
    MesDesde: { value: 1, attributes: { readOnly: false, focus: false, label: 'Mes Desde', hidden: "unset", } },
    AnoDesde: { value: new Date().getFullYear(), attributes: { readOnly: false, focus: false, label: 'Año Desde', hidden: "unset", } },
    Todos: { value: true, attributes: { readOnly: false, focus: false, label: 'Todos' } },
    Nota: { value: 'Nota: El rango va hasta la nómina actual', attributes: { readOnly: false, focus: false, hidden: "unset", } },


  };
  const [datos, setDatos] = useState(DatosConst);
  const [token, setToken] = useSessionStorage('token', '');
  const [usuario, setUsuario] = useSessionStorage('usuario');
  const [empresa, setEmpresa] = useSessionStorage('empresa');


  const [selectedOptionTipoAumt, setSelectedOptionTipoAumt] = useState(listaTipoAumt[0]);
  const listaMesesT = Config.listaMeses;
  const [selectedOptionMes, setSelectedOptionMes] = useState(itemSelect(1, listaMesesT));
  const [listaEmpleados, setListaEmpleados] = useState([]);


  const columnasEmp = [{ dataField: 'Empleado', text: 'Número', csvText: 'Numero', sort: true }, { dataField: 'NombreCompleto', text: 'Nombre', sort: true }];
  const [selectedEmpleado, setSelectedEmpleado] = useState(undefined);
  const selectRowEmp = { mode: 'radio', clickToSelect: true, hideSelectColumn: true, onSelect: (row) => onRowSelectEmp(row), bgColor: '#10a599' };
  const [selectModalEmp, setSelectModalEmp] = useState(undefined);

  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: "btnGuardar",
      clase: "btn btn-sm pull-right flipInX animated",
      evento: () => ingresarDatos(),
      leyenda: "",
      iclase: faSave,
      tooltip: "Guardar"
    }
  ]

  //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);
  }

    //modal errores
    const [validaSalariosPuesto,setValidaSalariosPuesto]  = useState(false); 
    const [TipoCambio, setTipoCambio] = useState(0);           
    const [selectedModalErrores, setselectedModalErrores] = useState(false);
    const [listaDatosErrores, setlistaDatosErrores] = useState([]); 
    const cellEditErrores = { mode: "click", autoSelectText: true, blurToSave: true };
    const selectRowErrores = { mode: 'radio', clickToSelect: true, hideSelectColumn: true, onSelect: (row, isSelected) => ()=>{}, bgColor: '#10a599' };       
    const columnasErrores = [
        {
            dataField: 'Empleado',
            text: 'Número',
            csvText: 'Número',
            sort: true,
            headerAlign: 'center',
            align: 'center',
            hidden: false,
            footer: (columnData, column, columnIndex) => {
                return `Total: ${listaDatosErrores.length}`;
            },
            footerStyle: { Color: '#ff0000', textAlign: 'left' }, headerStyle: { width: '10%' }, style: { width: '10%' },
        },
        {
            dataField: 'Cedula',
            text: 'Cédula',
            csvText: 'Cedula',
            sort: true,
            headerAlign: 'center',
            align: 'center',
            hidden: false,headerStyle: { width: '12%' }, style: { width: '12%' },
        },
        {
            dataField: 'NomCompleto2',
            text: 'Nombre',
            csvText: 'Nombre',
            sort: true,
            headerAlign: 'center',
            align: 'left',
            hidden: false, headerStyle: { width: '20%' }, style: { width: '20%' },
        },
        {
            dataField: 'DescripcionPuesto',
            text: 'Puesto',
            csvText: 'Puesto',
            sort: true,
            headerAlign: 'center',
            align: 'left',
            hidden: false, headerStyle: { width: '14.5%' }, style: { width: '14.5%' },
        },
        {
            dataField: 'SalMaximoPuesto',
            text: 'Salario Máximo',
            csvText: 'Salario Maximo',
            sort: true,
            headerAlign: 'center',
            align: 'right',
            hidden: false,
            formatter: (row, cell) => { return farmatearMontos(cell.SalMaximoPuesto) }, headerStyle: { width: '14.5%' }, style: { width: '14.5%' },
        },
        {
            dataField: 'SalarioBase',
            text: 'Nuevo Salario',
            csvText: 'Nuevo Salario',
            sort: true,
            headerAlign: 'center',
            align: 'right',
            hidden: false,
            formatter: (row, cell) => { return farmatearMontos(cell.SalarioBase) },headerStyle: { width: '14.5%' }, style: { width: '14.5%' },
        },
        {
            dataField: 'SalMaximoDiferencia',
            text: 'Diferencia',
            csvText: 'Diferencia',
            sort: true,
            headerAlign: 'center',
            align: 'right',
            hidden: false, 
            formatter: (row, cell) => { return farmatearMontos(cell.SalMaximoDiferencia) }, headerStyle: { width: '14.5%' }, style: { width: '14.5%' },
        }
    ];    
        const botonErrores = [

            {
                name: "btnErroresCancelar",
                clase: "btn btn-sm pull-right flipInX animated",
                evento: ()=>handleCerrarModalErr(),
                leyenda: "",
                iclase: faReply, 
                tooltip: "Cancelar"
            },
            {
                name: "btnErroresContinuar",
                clase: "btn btn-sm pull-right flipInX animated",
                evento: ()=> aplicaAumentoRetroActivo(),
                leyenda: "",
                iclase: faCheck,
                tooltip: "Continuar Aplicación"
            }            
        ]  


  const volverAtras = () => {
    historyMenu.push(SiteRutas.Empleados);
  }
  const Empleado_lista = async () => {
    const response = await Empleados_Listar_Busqueda_Request(token, empresa, -1, -1, -1, -1, -1, `'${Config.ee_activo}','${Config.ee_Contratado}','${Config.ee_Suspendido}','${Config.ee_Permiso}'`);

    if (response.Exitoso) {
      const _datos = response.Datos;//.filter(item => item.estado == 'A');
      setListaEmpleados(_datos);
    }
    else {
      const _login = manageError(response, props, '');
      spinnerModalMostrar(false, '', 3);
      if (!_login) { volverAtras(); }
      return false;
    }

  }
  useEffect(() => {
    if (!mounted.current) {
      muestraArbolEmpleados(false);
      const carga = async () => {
        await cargarDatosPantalla()
      }
      carga();
      mounted.current = true;
    }
  }, [])

  const cargarDatosPantalla = async () => {
      let spinnerLabel = 'Cargando datos...';
      spinnerModalMostrar(true, spinnerLabel, 3);


      //setDatos(_Datos);
      await Empleado_lista();

            const responseP = await ParametrosGenerales_Consulta_Request(token, empresa);

            if (responseP.Exitoso) {
                setTipoCambio(responseP.Datos.TipoCambio);
                setValidaSalariosPuesto(responseP.Datos.ValidaSalariosPuesto)
            } else {
                const _login = manageError(responseP, props, '');
                spinnerModalMostrar(false, '', 3);
                if (!_login) { volverAtras(); }
                return false;
            }         

      const _MenuNomb = await cargarMenuNombre(Config.Modulo, optSeg.TMenuSistema.AumentosRetroactivos.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 ingresarDatos = async () => {
    const _Valido = await validarCampos();
    if (_Valido) {
      const optSegopt = optSeg.TOpciones_Menu;
      let validar = validarMenuOpcion(optSegopt.Aplicar.value);
      if (!validar) {
        ingresarDatosSel();
      }
    }
  }

  const ingresarDatosSel = async () => {
    const _Valido = await validarCampos();
    if (_Valido) {
      handleButtonCC("Aumentos Retro-Activos");
      //volverAtras();
    }
  }

  const validarCampos = () => {
    const _datos = datos;
    if (parseFloat(_datos.Monto.value) <= 0) {
      Notificacion.error(`Error: El monto ${_datos.Monto.attributes.label} debe ser mayor a 0 `);
      return false;
    }
    if (_datos.Todos.value == false){
      if(_datos.Empleado.value.toString().trim().length ==  0){
        Notificacion.error(`Error: Debe seleccionar un empleado `);
        return false;        
      }
    }
    return true;
  }
  const handleButtonCC = (pTitulo) => {
    let resultado = false;
    Swal.fire({
      title: pTitulo,
      html: '<h4>¿Desea Realizar el Aumento Retro-Activo?</h4>',
      //text: '',
      type: 'question',
      showCancelButton: true,
      confirmButtonColor: '#10a599',
      cancelButtonColor: '#d33',
      confirmButtonText: '<h5><i className="fa fa-check fa-fw"></i> Sí</h5>',
      cancelButtonText: '<h5><i className="fa fa-remove fa-fw"></i> No</h5>',
      //backdrop:"linear-gradient(yellow, orange)",
      reverseButtons: true,
      allowOutsideClick: false,
    }).then((result) => {
      if (result.value) {
        resultado = true;
        aplicarDatos();
        // For more information about handling dismissals please visit
        // https://sweetalert2.github.io/#handling-dismissals
      } else if (result.dismiss === Swal.DismissReason.cancel) {
        resultado = false;
        //    Swal.fire(
        //      'Cancelled',
        //      'Your imaginary file is safe :)',
        //      'error'
        //    )
      }
    })
    return resultado;
  }

    const aplicarDatos = async () => {
        const session = new Session();
        const _GenPaisModulo = session.get('pais');
        if ((validaSalariosPuesto == true) && (_GenPaisModulo == Config.PaisCostaRica )){
            await validarDatosSalario();
        }else{
            await aplicaAumentoRetroActivo();
        };


    }


    const validarDatosSalario= async()=>{
            let spinnerLabel = 'Validando aumentos...';
            spinnerModalMostrar(true, spinnerLabel, 3);
            const _data = llenarDatos();
            const response = await AumentoSalarial_ValidarSalarioSegunPuesto_Request(token, _data);
    
            spinnerModalMostrar(false, '', 3);
    
            if (response.Exitoso == false) {
                setlistaDatosErrores(response.Datos);
                spinnerModalMostrar(false, "", 3);
                setselectedModalErrores(true);
                return;            
            } else {
                spinnerModalMostrar(false, '', 3);
              // si no hay error continua
              await aplicaAumentoRetroActivo();
            }
    
    
    }
const llenarDatos = () => {
        
        const PorEmpleado =  'E';
        const AumentoPorPorcentaje = listaTipoAumt[0];
        const AumentoPorMonto = listaTipoAumt[1];
        const AumentoPorSalario = listaTipoAumt[2];
        const Empleado = datos.Empleado.value == "" ? -1 : datos.Empleado.value;
        const Porcentaje = parseFloat(datos.Monto.value !== "" ? datos.Monto.value : 0);
        const Monto = parseFloat(datos.Monto.value !== "" ? datos.Monto.value : 0);
        const Salario = parseFloat(datos.Monto.value !== "" ? datos.Monto.value : 0);
        const Area = 0;
        const Depto = 0;
        const Seccion = 0;
        const Oficina = 0;
        const Puesto = 0;
        const SalarioBase = datos.SalBase.value !== null ? datos.SalBase.value : 0;

        let valorFiltro = 0;
        let valorAumento = 0;

        valorFiltro  = datos.Todos.value == false ? Empleado :0;
        valorAumento = Monto;


        const _data = llenarListaDatos(PorEmpleado, valorFiltro, SalarioBase, selectedOptionTipoAumt.value, valorAumento, '');

        return _data;
    }  
    
    const llenarListaDatos = (AumentoPor, ValorFiltro, SalarioBase, TipoAumento, ValorAumento, Comentario) => {
        let _data = {};

        _data.Empresa = empresa;
        _data.AumentoPor = AumentoPor;
        _data.ValorFiltro = ValorFiltro;
        _data.SalarioBase = SalarioBase;
        _data.TipoAumento = TipoAumento;
        _data.ValorAumento = ValorAumento;
        _data.Comentario = Comentario;
        _data.Usuario_Modifica = usuario;

        return _data;
    }    
  const aplicaAumentoRetroActivo = async () => {
    let resultado = '';
    const _Datos = datos;
    spinnerModalMostrar(true, 'Aumento retroactivo ...', 3);
    const _Proposito = (_Datos.Todos.value == true ? 'T' : 'E');
    const _Desde = new Date(_Datos.AnoDesde.value, selectedOptionMes.value - 1, 1);
    const _empl = (_Datos.Empleado.value.toString().trim().length > 0 ? _Datos.Empleado.value : 0);
    resultado = await AumentoRetroActivo_Request(token, empresa, _Desde, _Proposito, _empl, selectedOptionTipoAumt.value, _Datos.Monto.value, usuario);
    if (resultado.Exitoso) {
      handleCerrarModalErr();
      Notificacion.success(`Se realizo el aumento retroactivo con éxito.`);
      //await cargarDatos();
    }
    else {
      const _login = manageError(response, props, '');
      handleCerrarModalErr()
      spinnerModalMostrar(false, '', 3);
      if (_login) { return false; };
    }

    spinnerModalMostrar(false, '', 3);
  }
  const onhandleSelectedOptionTipoAumt = (selectedOptionTipoAumt) => {
    let _datos = { ...datos };
    _datos.Monto.attributes.label = selectedOptionTipoAumt.label;
    _datos.Monto.value = farmatearMontos(0);
    setSelectedOptionTipoAumt(selectedOptionTipoAumt);
    setDatos(_datos);
  };

  const onChangeInputDecimal = (e) => {
    const name = e.target.name;
    const value = e.target.value;
    const _Tipo = selectedOptionTipoAumt.value;
    const valido = (_Tipo == 'P' ? validarPorcentaje(value) : validarDecimal(value));
    if (valido) {
      let newAttributes = datos[name].attributes;
      // newAttributes.focus = true; //Se asigna foco al componente
      let Datos = Object.assign({}, datos, { [name]: { value: value, attributes: newAttributes } })
      setDatos(Datos);
    }
  }

  const onFormato = (valor) => {
    const _Tipo = selectedOptionTipoAumt.value;
    return (_Tipo == 'P' ? farmatearPorcentaje(valor) : farmatearMontos(valor));
  }

  const onChangeEditar = (e) => {

    const name = e.target.name;
    const value = datos[name].value;// 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 onhandleSelectMes = (selectedOptionMes) => {
    setSelectedOptionMes(selectedOptionMes);
  }

  const handleCheckBox = async (event) => {

    const name = event.target.name;
    const value = event.target.checked;
    let newAttributes = datos[name].attributes;
    // newAttributes.focus = true; //Se asigna foco al componente
    let Datos = Object.assign({}, datos, { [name]: { value: value, attributes: newAttributes } });
    Datos.Empleado.attributes.readOnly = value;
    Datos.Empleado.attributes.readOnlyBoton = value;
    Datos.EmpleadoNombre.value = '';
    Datos.Empleado.value = '';
    Datos.SalBase.value = 0;
    setDatos(Datos);
  }

  const onhandleAnoChange = (event) => {

    const valido = validarIntVig(event.target.value);
    if (valido) {

      let _Datos = { ...datos };

      _Datos.AnoDesde.value = event.target.value;
      setDatos(_Datos);

    }
  }

  const validarSoloNumeros = (ev) => {
    const text = /^[0-9]+$/;

    const value = ev.target.value;

    if (ev.type == "blur" && ev.keyCode != 8 && ev.keyCode != 46) {

      if ((value != "") && (!text.test(value))) {
        Notificacion.warning(`Debe ingresar un valor numérico.`);
        return false;
      } else if (value == "") {
        return false;
      }

    }

    return true;

  }

  const validarAnio = (ev) => {
    const text = /^[0-9]+$/;
    const year = ev.target.value;

    let _Datos = { ...datos };

    if (ev.type == "blur" || year.length == 4 && ev.keyCode != 8 && ev.keyCode != 46) {
      if (year != 0) {

        const current_year = new Date().getFullYear();

        if ((year != "") && (!text.test(year))) {

          _Datos.AnoDesde.value = current_year;

          setDatos(_Datos);

          Notificacion.warning('Debe ingresar un valor numérico.');

          return false;
        }

        if (year.length != 4) {

          _Datos.AnoDesde.value = current_year;

          setDatos(_Datos);

          Notificacion.warning('Debe ingresar un año válido');

          return false;
        }

        if ((year < 1900) || (year > current_year)) {

          _Datos.AnoDesde.value = current_year;

          setDatos(_Datos);

          Notificacion.warning('Debe ingresar un año válido');

          return false;
        }
        return true;
      }
    }
  }

  //*********MODAL**************************************/

  const seleccionModalEmp = async () => {
    let _selectedEmpleado = selectedEmpleado;

    if (!!_selectedEmpleado) {
      let Datos = datos;
      const listEmpleado = listaEmpleados;
      const Empleado = listEmpleado.filter(item => item.Empleado == _selectedEmpleado.Empleado);
      Datos.EmpleadoNombre.value = _selectedEmpleado.NombreCompleto;
      Datos.Empleado.value = _selectedEmpleado.Empleado;
      Datos.EmpleadoNombre.value = Empleado[0].NombreCompleto;
      Datos.Empleado.value = Empleado[0].Empleado;
      Datos.SalBase.value = Empleado[0].SalarioBase;

      setSelectModalEmp(undefined)
      setSelectedEmpleado(undefined);
      setDatos(Datos);
      //setListaHijos(listaHijos);
    }
    else {
      Notificacion.warning('Debe seleccionar un empleado');
      Progress.done();
    }
  }

  const handleModalEmp = () => {
    setSelectModalEmp(true);
  }
  const cerrarModalEmp = () => {
    setSelectModalEmp(undefined);
    setSelectedEmpleado(undefined);
  }

  const onRowSelectEmp = (row) => {
    setSelectedEmpleado(row);
  }
  const onDoubleClickEmp = async (e, row, rowIndex) => {
    const listEmpleado = listaEmpleados;
    const Empleado = listEmpleado.filter(item => item.Empleado == row.Empleado);
    let Datos = { ...datos };
    Datos.EmpleadoNombre.value = Empleado[0].NombreCompleto;
    Datos.Empleado.value = Empleado[0].Empleado;
    Datos.SalBase.value = Empleado[0].SalarioBase;
    setSelectModalEmp(undefined);
    setSelectedEmpleado(undefined);
    setDatos(Datos);
    //setListaHijos(listaHijos);    
  }

  const onKeyPressEmp = async (e) => {
    const _empleado = e.target.value.toString().trim();
    let Datos = { ...datos };
    if (e.charCode == 13) {
      if (_empleado.length > 0) {
        const listEmpleado = listaEmpleados;
        const Empleado = listEmpleado.filter(item => item.Empleado == _empleado);

        if (Empleado.length > 0) {
          Datos.EmpleadoNombre.value = Empleado[0].NombreCompleto;
          Datos.Empleado.value = Empleado[0].Empleado;
          Datos.SalBase.value = Empleado[0].SalarioBase;
          setDatos(Datos);
        } else {
          Datos.Empleado.value = '';
          setDatos(Datos);
          Notificacion.warning('Empleado no existe');
        }
      }
    }
  }
  const onBlurEmpl = async () => {
    let Datos = { ...datos };
    if (Datos.Empleado.value.toString().trim().length > 0) {
      const _listEmpleado = listaEmpleados;
      const Empleado = _listEmpleado.filter(item => item.Empleado == Datos.Empleado.value);
      //Datos.EmpleadoNombre.value = Empleado[0].NombreCompleto;
      // Datos.Empleado.value = Empleado[0].Empleado;
      if (Empleado.length > 0) {
        Datos.EmpleadoNombre.value = Empleado[0].NombreCompleto;
        Datos.Empleado.value = Empleado[0].Empleado;
        Datos.SalBase.value = Empleado[0].SalarioBase;
        setDatos(Datos);
      } else {
        Datos.Empleado.value = '';
        setDatos(Datos);
        Notificacion.warning('Empleado no existe');
      }
    }
  }

  const onChangeInputEmp = (e) => {
    const name = e.target.name;
    const value = e.target.value;
    let newAttributes = datos[name].attributes;
    // newAttributes.focus = true; //Se asigna foco al componente 
    let Datos = Object.assign({}, datos, { [name]: { value: value, attributes: newAttributes } })
    Datos.EmpleadoNombre.value = '';
    setDatos(Datos);
  }

    //modal de errores

    
    const handleCerrarModalErr = () => {
        setselectedModalErrores(false);
    };


  //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.Aplicar.value:
          ingresarDatosSel();
          break;
        default:
          break;
      }
    }
  }


  return (
    <Fragment>
      <AumentoRetroactivosInt
        botones={botones}
        Titulo={'Aumentos Retro-Activos'}
        Datos={datos}
        onChangeInputDecimal={onChangeInputDecimal}
        onChangeEditar={onChangeEditar}
        onFormato={onFormato}
        listaTipoAumt={listaTipoAumt}
        selectedOptionTipoAumt={selectedOptionTipoAumt}
        onhandleSelectedOptionTipoAumt={onhandleSelectedOptionTipoAumt}
        onhandleSelectMes={onhandleSelectMes}
        listaMeses={listaMesesT}
        onBlurEmpl={onBlurEmpl}
        onChangeInputEmp={onChangeInputEmp}
        onKeyPressEmp={onKeyPressEmp}
        handleModalEmp={handleModalEmp}
        selectedOptionMes={selectedOptionMes}
        handleCheckBox={handleCheckBox}
        validarAnio={validarAnio}
        validarSoloNumeros={validarSoloNumeros}
        onhandleAnoChange={onhandleAnoChange}
      />
      <ModalBusquedaEmp
        selectedModal={selectModalEmp}
        contentLabel={'selectedBusquedasEmp'}
        datos={listaEmpleados}
        id={'Empleado'}
        columnas={columnasEmp}
        striped={false}
        hover={true}
        condensed={false}
        selectRow={selectRowEmp}
        onDoubleClick={onDoubleClickEmp}
        label={'Lista de Empleados'}
        cerrarModal={cerrarModalEmp}
        seleccionModal={seleccionModalEmp}
        verLHOC={false}
        nombreCSV={'BusquedaEmpleados'}
      />
      <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}
      />
      <ModalErrores
          selectedModal={selectedModalErrores}
          datos={listaDatosErrores}
          columnas={columnasErrores}
          id={"Empleado"}
          label={"Errores en la carga"}
          selectRow={selectRowErrores}
          cellEdit={cellEditErrores}
          botones={botonErrores}
          cerrarModal={handleCerrarModalErr}
          titulo={'Listado de colaboradores que presentan un salario mayor al salario máximo registrado en el puesto'}
          titulo2={' Presionar el botón "Continuar" para seguir aplicando los aumentos a los colaboradores que no están en esta lista. De lo contrario presionar "Cancelar" para cancelar el proceso y no realizar ningún aumento.'}
      />        
    </Fragment>
  );
};
export default withRouter(memo(aumentoRetroactivos));