package com.dacrt.SBIABackend.security.controler;

import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Optional;
import java.util.Set;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;

import org.apache.commons.lang3.StringUtils;
import org.apache.tomcat.util.json.JSONParser;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.json.JsonMapper;
import com.fasterxml.jackson.databind.node.*;
import com.fasterxml.jackson.*;
import com.fasterxml.jackson.core.type.TypeReference;
import com.dacrt.SBIABackend.dto.Mensaje;
//import com.dacrt.SBIABackend.entity.LineaOperacion;
//import com.dacrt.SBIABackend.entity.Proceso;
import com.dacrt.SBIABackend.security.dto.AccesoDto;
import com.dacrt.SBIABackend.security.dto.AuditRequestDto;
import com.dacrt.SBIABackend.security.dto.EntryDto;
import com.dacrt.SBIABackend.security.dto.EntrypointsDto;
import com.dacrt.SBIABackend.security.dto.ParamsDto;
import com.dacrt.SBIABackend.security.dto.PrivilegeUniqueResponseDto;
import com.dacrt.SBIABackend.security.dto.PrivilegesAllDto;
import com.dacrt.SBIABackend.security.dto.PrivilegesDto;
import com.dacrt.SBIABackend.security.dto.RespuestaDto;
import com.dacrt.SBIABackend.security.dto.RespuestaMsgDto;
import com.dacrt.SBIABackend.security.dto.RespuestaValueDto;
import com.dacrt.SBIABackend.security.dto.RolAccesoDto;
import com.dacrt.SBIABackend.security.dto.RolNameDto;
import com.dacrt.SBIABackend.security.dto.RoleDto;
import com.dacrt.SBIABackend.security.dto.RolesDto;
import com.dacrt.SBIABackend.security.dto.RolesResponseDto;
import com.dacrt.SBIABackend.security.dto.RolesUserDto;
import com.dacrt.SBIABackend.security.dto.UsersListDto;
import com.dacrt.SBIABackend.security.entity.Params;
import com.dacrt.SBIABackend.security.entity.Roles;
import com.dacrt.SBIABackend.security.entity.Users;
import com.dacrt.SBIABackend.security.repository.AuditRepository;
import com.dacrt.SBIABackend.security.repository.ParamsRepository;
import com.dacrt.SBIABackend.security.repository.PrivilegesRepository;
import com.dacrt.SBIABackend.security.repository.RolesPrivilegesRepository;
import com.dacrt.SBIABackend.security.repository.RolesRepository;
import com.dacrt.SBIABackend.security.repository.UsersRepository;
import com.dacrt.SBIABackend.security.service.MenuService;

import com.dacrt.SBIABackend.security.service.SecurityService;

import com.dacrt.SBIABackend.security.service.UsersService;
import com.dacrt.SBIABackend.utils.HttpReqRespUtils;

@RestController
//@RequestMapping("/roles")
@CrossOrigin(origins = "*")
//@CrossOrigin(origins = "*")
public class RolesController<JSONObject> {

	@PersistenceContext
	private EntityManager entityManager;

	@Autowired
	private UsersRepository usersRepository;

	@Autowired
	private ParamsRepository paramsRepository;

	@Autowired
	private RolesRepository rolesRepository;

	@Autowired
	private PrivilegesRepository privilegesRepository;

	@Autowired
	private RolesPrivilegesRepository rolesPrivilegesRepository;

	@Autowired
	UsersService usersService;

	@Autowired
	MenuService menuService;
	
	@Autowired
	SecurityService securityService;

	@Autowired
	private AuditRepository auditRepository;

	@Autowired
	private ObjectMapper objectMapper;

	/*
	 * @Autowired RolOpcionDeBIAService rolOpcionDeBIAService;
	 */

	Logger logger = LoggerFactory.getLogger(RolesController.class);

	@PostMapping("/roles")
	public ResponseEntity<?> listarRoles(HttpServletRequest request, @RequestBody UsersListDto tiposfiltros)
			throws ParseException {
		RespuestaMsgDto respuesta = new RespuestaMsgDto("");
		HttpStatus estatus = HttpStatus.FORBIDDEN;
		RolesResponseDto rolesResponseDto = new RolesResponseDto();
		PrivilegesAllDto detallePrivilege;
		Long cuantosregistro = (long) 0;
		List<RoleDto> listasRoles = new ArrayList<>();

		String sessionid = request.getHeader("Authorization");
		Date fecha = new Date();
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String dataFormattata = formatter.format(fecha);
		Date fechaDate = formatter.parse(dataFormattata);
		AuditRequestDto auditDto = new AuditRequestDto();

		String searchIn = "";
		String searchModule = "";
		String searchUsr = "";
		String contentIn = "";
		int orderIn = 0;
		int offsetIn = 0;
		int numofrecordsIn = 0;

		Optional<Params> deSessDuration = paramsRepository.findByParamname("SESSION_DURATION");
		String SessionDuration = deSessDuration.get().getValue();
		Optional<Params> deEntryPoint = paramsRepository.findByParamname("ENTRY_POINT");
		String entrypoint = deEntryPoint.get().getValue();

		int duracionSession = Integer.parseInt(SessionDuration);
		Date fecha2 = new Date();
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(fecha2); // tuFechaBase es un Date;
		// calendar.add(Calendar.MINUTE, minutosASumar); //minutosASumar es int.
		calendar.add(Calendar.MINUTE, duracionSession); // horasASumar es int.
		// lo que más quieras sumar
		Date ValidThrufechaSalida = calendar.getTime(); // Y ya tienes la fecha sumada.

		// Verificar si la sesión está vacìa
		if (sessionid == null) {
			respuesta.setMsg("Llamada al servicio malformado");
			return new ResponseEntity(respuesta, HttpStatus.BAD_REQUEST);
		} else {
			sessionid = sessionid.substring(7);
			// verifico si la sesión del usuario existe.
			Optional<Users> encontreSessionUsuario = usersRepository.getBySessionid(sessionid);

			if (encontreSessionUsuario.isPresent()) { // si la sesión del usuario existe
				
				String fechaComoCadena;
				   Date FechaReg = encontreSessionUsuario.get().getValidthru(); 
				// Llamada a la funcion que validad el tiempo de Session, retorna la fecha
				// sumandole el tiempo de session activa, y vacio si no esta activa
					   
					   // fechaComoCadena  = securityService.consultarSessionActiva(FechaReg,fecha2);
				fechaComoCadena = securityService.consultarSessionActiva(FechaReg, fecha2,
				encontreSessionUsuario.get().getId());
						   
				if (fechaComoCadena == "") {
						    String var2 = "";
							boolean bloked2 = false;
							RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var2);
					// respuestaDto.setBlocked(bloked);
							respuestaDto.setMsg("Sesión expirada o inválida"); 
							return new ResponseEntity(respuestaDto, HttpStatus.UNAUTHORIZED);
						   
					    }

				// Obtengo el rol de usuario y verifico si corresponde al privilegio del usuario
				int rolisvalid = 0;
				rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 620);
				if (rolisvalid == 0) {
					respuesta.setMsg("No tiene los Privilegios");
					return new ResponseEntity(respuesta, HttpStatus.FORBIDDEN);
				}
				// Obtengo los datos del Body
				searchIn = tiposfiltros.getFilters().getSearch(); // dato de busqueda por nombre
				

			   /* String Salida = usersService.verificarCaracteresValidosConRegex(searchIn);
				  
				  if (Salida=="NOOK") {
					  String var = "";
						boolean bloked = false;
						RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var);
						//respuestaDto.setBlocked(bloked);
						respuestaDto.setMsg("Caracteres no permitidos en la busqueda"); 
						return new ResponseEntity(respuestaDto, HttpStatus.BAD_REQUEST);
				  }*/
				  
				searchModule = tiposfiltros.getFilters().getModule(); // Modulo del Sistema
				searchUsr = tiposfiltros.getFilters().getUser();
				orderIn = tiposfiltros.getOrder();// Campo por el que puede ser ordenado el listado
				offsetIn = tiposfiltros.getOffset();// Primer registro a mostrar
				numofrecordsIn = tiposfiltros.getNumofrecords();// Número de registros a mostrar
				contentIn = tiposfiltros.getContent();
				// Verifico los Shorcouts
				if (contentIn != null && contentIn != "")
					menuService.iscontentdiffnull(contentIn, encontreSessionUsuario.get().getId());

			} else { // Si la sesión que viene es inválida
				respuesta.setMsg("Sesión expirada o inválida");
				return new ResponseEntity(respuesta, HttpStatus.BAD_REQUEST);
			}
		}

		try {

			// Sentencia General
			String SentenciaBase = "SELECT new com.dacrt.SBIABackend.security.dto.RolesDto (r.id, r.name,r.createdat) FROM Roles r";
			String QueryTotal = "";
			String name = "r.name"; // buscar por nombre
			String createdat = "r.createdat";
			String lowername = "LOWER(r.name)"; // se convierte en minúscula
			String LowerSearch = searchIn.toLowerCase(); // se convierte en minúscula

			// Se verifica si viene dato en el campo search para efectuar la búsqueda
			switch (searchIn) {
			case "": // viene sin busqueda por el like
				QueryTotal = SentenciaBase;
				break;
			default: // viene con el parametro para buscar por el like
				QueryTotal = SentenciaBase + " WHERE " + lowername + " LIKE  " + "'%" + LowerSearch + "%'";
			}

			switch (orderIn) {
			case 1: // ordena por createdat y name ascendente
				QueryTotal = QueryTotal + " ORDER BY " + createdat + " ASC" + "," + name + " ASC";
				break;

			case 2:// ordena por createdat ascendente
				QueryTotal = QueryTotal + " ORDER BY " + createdat + " ASC";
				break;

			case 3: // ordena por name ascendente
				QueryTotal = QueryTotal + " ORDER BY " + name + " ASC";
				break;

			case -1:// ordena por createdat y name descendente
				QueryTotal = QueryTotal + " ORDER BY " + createdat + " DESC" + "," + name + " DESC";
				break;

			case -2:// ordena por createdat descendente

				QueryTotal = QueryTotal + " ORDER BY " + createdat + " DESC";
				break;

			case -3:// ordena por name descendente
				QueryTotal = QueryTotal + " ORDER BY " + name + " DESC";
				break;

			default:
				// Manejo de excepciones
				respuesta.setMsg("Error interno del servidor");
				estatus = HttpStatus.INTERNAL_SERVER_ERROR;
				return new ResponseEntity(respuesta, estatus);
			}

			// Se mapea la entidad se le pasa el query y lo bota como un tipo de objeto
			// RoleDto-Buscar en los DTO
			TypedQuery<RolesDto> roles = entityManager.createQuery(QueryTotal, RolesDto.class);
			cuantosregistro = (long) roles.getResultList().size();
			roles.setFirstResult(offsetIn);
			roles.setMaxResults(numofrecordsIn);
			RoleDto role = new RoleDto();
			List<RoleDto> listacompletaRoles = new ArrayList();
			List<RolesDto> listacompleta = roles.getResultList();

			// Se construye el Dto de Roles de Respuesta según los privilegios que
			// tenga el usuario
			detallePrivilege = new PrivilegesAllDto();
			if (privilegesRepository.existsById(621))
				detallePrivilege.setUpdate(true);
			else
				detallePrivilege.setUpdate(false);

			if (privilegesRepository.existsById(620))
				detallePrivilege.setView(true);
			else
				detallePrivilege.setView(false);

			if (privilegesRepository.existsById(622))
				detallePrivilege.setAdd(true);
			else
				detallePrivilege.setAdd(false);

			if (privilegesRepository.existsById(623))
				detallePrivilege.setDelete(true);
			else
				detallePrivilege.setDelete(false);

			for (RolesDto rol : listacompleta) {
				role.setId(rol.getId());
				role.setName(rol.getName());
				listacompletaRoles.add(role);
				role = new RoleDto();
			}

			rolesResponseDto.setNumofrecords(cuantosregistro);
			rolesResponseDto.setRecords(listacompletaRoles);
			rolesResponseDto.setPrivileges(detallePrivilege);
			// String var = URLDecoder.decode(entrypoint,StandardCharsets.UTF_8.toString());
			// JsonNode detallesJson = objectMapper.readTree(entrypoint);
			List<EntrypointsDto> lista = objectMapper.readValue(entrypoint, new TypeReference<List<EntrypointsDto>>() {
			});

			rolesResponseDto.setEntrypoints(lista);
			// respuesta si fue exitosa la consulta
			return ResponseEntity.ok(rolesResponseDto);

		} catch (Exception e) {
			// Manejo de excepciones
			respuesta.setMsg("Error interno del servidor");
			estatus = HttpStatus.INTERNAL_SERVER_ERROR;
		}  finally {
			if (entityManager != null && entityManager.isOpen()) {
				entityManager.close();
			}
		}

		return new ResponseEntity(respuesta, estatus);
	}

	@PostMapping("/roles/{roleid}")
	public ResponseEntity<?> actualizarRol(HttpServletRequest request, @RequestBody RolNameDto rolName,
			@PathVariable("roleid") final Integer roleid) throws ParseException {
		RespuestaMsgDto respuesta = new RespuestaMsgDto("");

		RespuestaValueDto respuestaValueDto;
		String var = "";
		boolean bloked = false;
		RespuestaDto respuestaDto = new RespuestaDto(var, bloked);

		HttpStatus estatus = HttpStatus.FORBIDDEN;
		RolesResponseDto rolesResponseDto = new RolesResponseDto();
		RoleDto detalleRoles;
		PrivilegesAllDto detallePrivilege;
		Long cuantosregistro = (long) 0;
		List<RoleDto> listasRoles = new ArrayList<>();
		List<PrivilegesAllDto> listasPrivelege = new ArrayList<>();

		String sessionid = request.getHeader("Authorization");
		Date fecha = new Date();
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String dataFormattata = formatter.format(fecha);
		Date fechaDate = formatter.parse(dataFormattata);
		AuditRequestDto auditDto = new AuditRequestDto();

		String searchIn = "";

		int orderIn = 0;
		int offsetIn = 0;
		int numofrecordsIn = 0;
		String nameRol = "";
		Optional<Params> deSessDuration = paramsRepository.findByParamname("SESSION_DURATION");
		String SessionDuration = deSessDuration.get().getValue();
		int duracionSession = Integer.parseInt(SessionDuration);
		Date fecha2 = new Date();
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(fecha2); // tuFechaBase es un Date;
		// calendar.add(Calendar.MINUTE, minutosASumar); //minutosASumar es int.
		calendar.add(Calendar.MINUTE, duracionSession); // horasASumar es int.
		// lo que más quieras sumar
		Date ValidThrufechaSalida = calendar.getTime(); // Y ya tienes la fecha sumada.

		if (sessionid == null) {
			respuesta.setMsg("Llamada al servicio malformado");
			return new ResponseEntity(respuesta, HttpStatus.BAD_REQUEST);
		} else {
			sessionid = sessionid.substring(7);
			Optional<Users> encontreSessionUsuario = usersRepository.getBySessionid(sessionid);
			if (encontreSessionUsuario.isPresent()) {
				
				String fechaComoCadena;
				   Date FechaReg = encontreSessionUsuario.get().getValidthru(); 
				// Llamada a la funcion que validad el tiempo de Session, retorna la fecha
				// sumandole el tiempo de session activa, y vacio si no esta activa
					   
					   // fechaComoCadena  = securityService.consultarSessionActiva(FechaReg,fecha2);
				fechaComoCadena = securityService.consultarSessionActiva(FechaReg, fecha2,
						encontreSessionUsuario.get().getId());
						   
				if (fechaComoCadena == "") {
						   
					    	RespuestaMsgDto respuestaDto2;
						    String var2 = "";
							boolean bloked2 = false;
							respuestaDto2 = new RespuestaMsgDto(var2);
					// respuestaDto.setBlocked(bloked);
							respuestaDto.setMsg("Sesión expirada o inválida"); 
							return new ResponseEntity(respuestaDto, HttpStatus.UNAUTHORIZED);
						   
					    }
					    
				if (roleid != 0) {
					boolean existeRol = rolesRepository.existsById(roleid);
					if (!existeRol) {
						respuesta.setMsg("Registro no encontrado");
						return new ResponseEntity(respuesta, HttpStatus.NOT_FOUND);
					} else {
						int rolisvalid = 0;
						rolisvalid = auditRepository
								.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 621);
						if (rolisvalid == 0) {
							respuesta.setMsg("No tiene los Privilegios");
							return new ResponseEntity(respuesta, HttpStatus.FORBIDDEN);
						}
						nameRol = rolesRepository.findById(roleid).get().getName();
						
						   String SalidaName= usersService.verificarCaracteresValidosConRegex(rolName.getName());
						
						    
						    if (SalidaName=="NOOK") {
								  String var2 = "";
									boolean bloked2 = false;
									RespuestaMsgDto respuestaDto2 = new RespuestaMsgDto(var2);
									//respuestaDto.setBlocked(bloked);
									respuestaDto.setMsg("Caracteres no permitidos en la busqueda"); 
									return new ResponseEntity(respuestaDto2, HttpStatus.BAD_REQUEST);
							  }

						if (rolesRepository.existsByName(rolName.getName())
								&& rolName.getName().compareTo(nameRol) != 0) {
							respuesta.setMsg("Registro duplicado");
							return new ResponseEntity(respuesta, HttpStatus.CONFLICT);
						}

						Optional<Roles> rolElegido = rolesRepository.findById(roleid);
						Roles rol = new Roles();
						rol.setId(rolElegido.get().getId());
						rol.setName(rolName.getName());
						rol.setCreatedat(rolElegido.get().getCreatedat());
						rol.setModifiedat(fecha2);
						rol.setEntrypoint(rolName.getEntrypoint());
						rolesRepository.save(rol);

						////////////////////////// INSERCION BLOQUE DE AUDITORIA///////////////////
						String module = "Roles";
						String Descmodule = "Se actualizó: " + rolElegido.get().getName();

						auditDto.setIpaddr(HttpReqRespUtils.getClientIpAddressIfServletRequestExist());

						String singo1 = "(";
						String singo2 = ")";
						String usryemail = encontreSessionUsuario.get().getUsr().concat(" ").concat(singo1)
								.concat(encontreSessionUsuario.get().getEmail().concat(singo2));
						auditDto.setUserref(usryemail);
						auditDto.setModule(module);
						auditDto.setDesc(Descmodule);
						auditDto.setCreatedat(fechaDate);
						usersService.registrarAuditSesion(auditDto);

						respuestaValueDto = new RespuestaValueDto(roleid);
						estatus = HttpStatus.OK;
						return new ResponseEntity(respuestaValueDto, estatus);

					}
				} else { // insertar Rol
					Roles rol = new Roles();
					if (rolesRepository.existsByName(rolName.getName())) {
						respuesta.setMsg("Registro duplicado");
						return new ResponseEntity(respuesta, HttpStatus.CONFLICT);
					}

					int rolisvalid = 0;
					rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(),
							622);
					if (rolisvalid == 0) {
						respuesta.setMsg("No tiene los Privilegios");
						return new ResponseEntity(respuesta, HttpStatus.FORBIDDEN);
					}

					rol.setName(rolName.getName());
					rol.setCreatedat(fecha2);
					rol.setModifiedat(fecha2);
					rol.setEntrypoint(rolName.getEntrypoint());
					Roles rolNuevo = rolesRepository.save(rol);
					////////////////////////// INSERCION BLOQUE DE AUDITORIA///////////////////
					String module = "Roles";
					String Descmodule = "Se agregó: " + rolName.getName();
					auditDto.setIpaddr(HttpReqRespUtils.getClientIpAddressIfServletRequestExist());

					String singo1 = "(";
					String singo2 = ")";
					String usryemail = encontreSessionUsuario.get().getUsr().concat(" ").concat(singo1)
							.concat(encontreSessionUsuario.get().getEmail().concat(singo2));
					auditDto.setUserref(usryemail);
					auditDto.setModule(module);
					auditDto.setDesc(Descmodule);
					auditDto.setCreatedat(fechaDate);
					usersService.registrarAuditSesion(auditDto);
					respuestaValueDto = new RespuestaValueDto(rolNuevo.getId());
					estatus = HttpStatus.OK;
					return new ResponseEntity(respuestaValueDto, estatus);
					// return new ResponseEntity(respuestaDto, estatus);
				}

			} else {
				respuesta.setMsg("Sesión expirada o inválida");
				estatus = HttpStatus.BAD_REQUEST;
				return new ResponseEntity(respuesta, estatus);
				// Error 400

			}

		}
		// return new ResponseEntity(respuestaDto, estatus);
	}

	@GetMapping("/roles/{roleid}")
	public ResponseEntity<?> getOneRol(HttpServletRequest request, @PathVariable("roleid") final Integer roleid)
			throws ParseException {
		RespuestaMsgDto respuesta = new RespuestaMsgDto("");
		HttpStatus estatus = HttpStatus.FORBIDDEN;
		try {

			RespuestaValueDto respuestaValueDto;
			String var = "";
			boolean bloked = false;
			RespuestaDto respuestaDto = new RespuestaDto(var, bloked);

			RolesResponseDto rolesResponseDto = new RolesResponseDto();
			RoleDto detalleRoles;
			PrivilegesAllDto detallePrivilege;
			Long cuantosregistro = (long) 0;
			List<RoleDto> listasRoles = new ArrayList<>();
			List<PrivilegesAllDto> listasPrivelege = new ArrayList<>();

			String sessionid = request.getHeader("Authorization");
			Date fecha = new Date();
			SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			String dataFormattata = formatter.format(fecha);
			Date fechaDate = formatter.parse(dataFormattata);
			AuditRequestDto auditDto = new AuditRequestDto();

			String searchIn = "";
			int orderIn = 0;
			int offsetIn = 0;
			int numofrecordsIn = 0;

			Optional<Params> deSessDuration = paramsRepository.findByParamname("SESSION_DURATION");
			String SessionDuration = deSessDuration.get().getValue();
			int duracionSession = Integer.parseInt(SessionDuration);
			Date fecha2 = new Date();
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(fecha2); // tuFechaBase es un Date;
			// calendar.add(Calendar.MINUTE, minutosASumar); //minutosASumar es int.
			calendar.add(Calendar.MINUTE, duracionSession); // horasASumar es int.
			// lo que más quieras sumar
			Date ValidThrufechaSalida = calendar.getTime(); // Y ya tienes la fecha sumada.
			SimpleDateFormat salida = new SimpleDateFormat("yyyy-MM-dd HH:mm"); // 2024-12-23 23:00
			String fechaComoCadena = salida.format(ValidThrufechaSalida);
			System.out.println(fechaComoCadena);

			if (sessionid == null) {
				respuesta.setMsg("Llamada al servicio malformado");
				return new ResponseEntity(respuesta, HttpStatus.BAD_REQUEST);
			} else {
				sessionid = sessionid.substring(7);
				Optional<Users> encontreSessionUsuario = usersRepository.getBySessionid(sessionid);
				if (encontreSessionUsuario.isPresent()) {
					
					// String fechaComoCadena;
					   Date FechaReg = encontreSessionUsuario.get().getValidthru(); 
					// Llamada a la funcion que validad el tiempo de Session, retorna la fecha
					// sumandole el tiempo de session activa, y vacio si no esta activa
						   
						   // fechaComoCadena  = securityService.consultarSessionActiva(FechaReg,fecha2);
					fechaComoCadena = securityService.consultarSessionActiva(FechaReg, fecha2,
							encontreSessionUsuario.get().getId());
							   
					if (fechaComoCadena == "") {
							   
						    	RespuestaMsgDto respuestaDto2;
							    String var2 = "";
								boolean bloked2 = false;
								respuestaDto2 = new RespuestaMsgDto(var2);
						// respuestaDto.setBlocked(bloked);
								respuestaDto.setMsg("Sesión expirada o inválida"); 
								return new ResponseEntity(respuestaDto, HttpStatus.UNAUTHORIZED);
							   
						    }
						    
					boolean existeRol = rolesRepository.existsById(roleid);
					if (!existeRol) {
						respuesta.setMsg("Registro no encontrado");
						return new ResponseEntity(respuesta, HttpStatus.NOT_FOUND);
					} else {
						int rolisvalid = 0;
						rolisvalid = auditRepository
								.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 620);
						Optional<Roles> rolElegido = rolesRepository.findById(roleid);

						EntryDto entry = new EntryDto();
						RolesUserDto entry2 = new RolesUserDto();
						entry2.setId(rolElegido.get().getId());
						entry2.setName(rolElegido.get().getName());
						entry2.setEntrypoint(rolElegido.get().getEntrypoint());
						entry.setEntry(entry2);
						entry.setSessionvalidthru(fechaComoCadena);
						estatus = HttpStatus.OK;
						return new ResponseEntity(entry, estatus);
					}
				} else {
					respuesta.setMsg("Sesión expirada o inválida");
					estatus = HttpStatus.UNAUTHORIZED;
					return new ResponseEntity(respuesta, estatus);
				}
			}
		} catch (Exception e) {// Error Interno
			// Manejo de excepciones
			respuesta.setMsg("Error interno del servidor");
			estatus = HttpStatus.INTERNAL_SERVER_ERROR;
			return new ResponseEntity(respuesta, estatus);
		}

	}

	@DeleteMapping("/roles/{roleid}")
	public ResponseEntity<?> borrarRol(HttpServletRequest request, @PathVariable("roleid") final Integer roleid)
			throws ParseException {
		RespuestaMsgDto respuesta = new RespuestaMsgDto("");
		HttpStatus estatus = HttpStatus.FORBIDDEN;
		RolesResponseDto rolesResponseDto = new RolesResponseDto();
		RoleDto detalleRoles;
		PrivilegesAllDto detallePrivilege;
		Long cuantosregistro = (long) 0;
		List<RoleDto> listasRoles = new ArrayList<>();
		List<PrivilegesAllDto> listasPrivelege = new ArrayList<>();
		String var = "";
		boolean bloked = false;
		RespuestaDto respuestaDto = new RespuestaDto(var, bloked);
		String sessionid = request.getHeader("Authorization");
		Date fecha = new Date();
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String dataFormattata = formatter.format(fecha);
		Date fechaDate = formatter.parse(dataFormattata);
		AuditRequestDto auditDto = new AuditRequestDto();
		RespuestaValueDto respuestaValueDto;
		String searchIn = "";
		String module = "";
		String Descmodule = "";
		
		int orderIn = 0;
		int offsetIn = 0;
		int numofrecordsIn = 0;

		Optional<Params> deSessDuration = paramsRepository.findByParamname("SESSION_DURATION");
		String SessionDuration = deSessDuration.get().getValue();
		int duracionSession = Integer.parseInt(SessionDuration);
		Date fecha2 = new Date();
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(fecha2); // tuFechaBase es un Date;
		// calendar.add(Calendar.MINUTE, minutosASumar); //minutosASumar es int.
		calendar.add(Calendar.MINUTE, duracionSession); // horasASumar es int.
		// lo que más quieras sumar
		Date ValidThrufechaSalida = calendar.getTime(); // Y ya tienes la fecha sumada.

		if (sessionid == null) {
			respuesta.setMsg("Llamada al servicio malformado");
			estatus = HttpStatus.BAD_REQUEST;
			return new ResponseEntity(respuesta, estatus);
		} else {
			sessionid = sessionid.substring(7);
			Optional<Users> encontreSessionUsuario = usersRepository.getBySessionid(sessionid);

			if (encontreSessionUsuario.isPresent()) {
				
				String fechaComoCadena;
				   Date FechaReg = encontreSessionUsuario.get().getValidthru(); 
				// Llamada a la funcion que validad el tiempo de Session, retorna la fecha
				// sumandole el tiempo de session activa, y vacio si no esta activa
					   
					   // fechaComoCadena  = securityService.consultarSessionActiva(FechaReg,fecha2);
				fechaComoCadena = securityService.consultarSessionActiva(FechaReg, fecha2,
						encontreSessionUsuario.get().getId());
				if (fechaComoCadena == "") {
						   
					    	RespuestaMsgDto respuestaDto2;
						    String var2 = "";
							boolean bloked2 = false;
							respuestaDto2 = new RespuestaMsgDto(var2);
					// respuestaDto.setBlocked(bloked);
							respuestaDto.setMsg("Sesión expirada o inválida"); 
							return new ResponseEntity(respuestaDto, HttpStatus.UNAUTHORIZED);
						   
					    }
					    
				int rolisvalid = 0;
				rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 623);
				if (rolisvalid == 0) {
					respuesta.setMsg("No tiene los Privilegios");
					estatus = HttpStatus.FORBIDDEN;
					return new ResponseEntity(respuesta, estatus);
				}

				try {
					int existeRolUsr = usersRepository.existsByRolid(roleid);
					if (existeRolUsr == 0) {
						boolean existe = rolesRepository.existsById(roleid);
						if (existe) {
							// Borro los privilegios del rol
							rolesPrivilegesRepository.borrarRol(roleid);
							Optional<Roles> useradelete = rolesRepository.findById(roleid);
							// Borro el rol
							rolesRepository.deleteById(roleid);

							////////////////////////// INSERCION BLOQUE DE AUDITORIA///////////////////
							module = "Roles";
							Descmodule = " Se eliminó: " + useradelete.get().getName();

							auditDto.setIpaddr(HttpReqRespUtils.getClientIpAddressIfServletRequestExist());

							String singo1 = "(";
							String singo2 = ")";
							String usryemail = encontreSessionUsuario.get().getUsr().concat(" ").concat(singo1)
									.concat(encontreSessionUsuario.get().getEmail().concat(singo2));
							auditDto.setUserref(usryemail);
							auditDto.setModule(module);
							auditDto.setDesc(Descmodule);
							auditDto.setCreatedat(fechaDate);
							usersService.registrarAuditSesion(auditDto);

							respuestaValueDto = new RespuestaValueDto(roleid);
							estatus = HttpStatus.OK;
							return new ResponseEntity(respuestaValueDto, estatus);

						} else {// Registro no encontrado
							respuesta.setMsg("Registro no encontrado");
							estatus = HttpStatus.NOT_FOUND;
							return new ResponseEntity(respuesta, estatus);

						}
					} else {
						respuesta.setMsg("Error de Dependencias");
						estatus = HttpStatus.CONFLICT;
						return new ResponseEntity(respuesta, estatus);
					}
				} catch (Exception e) {// Error Interno
					// Manejo de excepciones
					respuesta.setMsg("Error interno del servidor");
					estatus = HttpStatus.INTERNAL_SERVER_ERROR;
					return new ResponseEntity(respuesta, estatus);
				}
			} else {
				respuesta.setMsg("Sesión expirada o inválida");
				estatus = HttpStatus.UNAUTHORIZED;
				return new ResponseEntity(respuesta, estatus);

			}

		}

	}

}