package com.dacrt.SBIABackend.controler;

import java.net.URI;
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 javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
import javax.servlet.http.HttpServletRequest;
import javax.transaction.Transactional;

import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.jdbc.core.JdbcTemplate;
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.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import com.dacrt.SBIABackend.dto.ChannelDto;
import com.dacrt.SBIABackend.dto.CoverageChannelResponseDto;
import com.dacrt.SBIABackend.dto.CoverageChannelsListDto;
import com.dacrt.SBIABackend.dto.CoverageChannelsRecordDet;
import com.dacrt.SBIABackend.dto.CoverageDto;
import com.dacrt.SBIABackend.dto.CoverageEvalChannelHistoryDto;
import com.dacrt.SBIABackend.dto.CoverageEvalChannelRecordsDto;
import com.dacrt.SBIABackend.dto.CoverageEvalProcessHistoryDto;
import com.dacrt.SBIABackend.dto.CoverageEvalProcessRecordsDto;
import com.dacrt.SBIABackend.dto.CoverageEvaluationDto;
import com.dacrt.SBIABackend.dto.CoverageHistoryActualizarDto;
import com.dacrt.SBIABackend.dto.CoverageRecordDet;
import com.dacrt.SBIABackend.dto.EntryCoverageChannelsDto;
import com.dacrt.SBIABackend.dto.EntryCoverageChannelsDto2;
import com.dacrt.SBIABackend.dto.LevelDto;
import com.dacrt.SBIABackend.dto.OperationlineDto;
import com.dacrt.SBIABackend.dto.OperationlineDtoStatus2;
import com.dacrt.SBIABackend.dto.ProcessResponDto;
import com.dacrt.SBIABackend.dto.StateDetailDto;
import com.dacrt.SBIABackend.dto.StateDto;
import com.dacrt.SBIABackend.dto.StatrategiesDetalladaDto;
import com.dacrt.SBIABackend.dto.StatusDto2;
import com.dacrt.SBIABackend.dto.StatusEvalUnitsResponseDto;
import com.dacrt.SBIABackend.dto.StrategiesDetDto;
import com.dacrt.SBIABackend.dto.TotalPosiResUnitsDto;
import com.dacrt.SBIABackend.dto.UnitsResponseDto;
import com.dacrt.SBIABackend.dto.responseDto.CoverageProcessUnitResponseDto;
import com.dacrt.SBIABackend.entity.Coveragechannels;
import com.dacrt.SBIABackend.entity.Coveragechannelshistory;
import com.dacrt.SBIABackend.entity.Strategiesdet;
import com.dacrt.SBIABackend.repository.CampaignsRepository;
import com.dacrt.SBIABackend.repository.CoveragechannelsRepository;
import com.dacrt.SBIABackend.repository.CoveragechannelshistoryRepository;
import com.dacrt.SBIABackend.repository.StrategiesdetRepository;
import com.dacrt.SBIABackend.security.dto.AuditRequestDto;
import com.dacrt.SBIABackend.security.dto.PrivilegesAllDto;
import com.dacrt.SBIABackend.security.dto.RespuestaMsgDto;
import com.dacrt.SBIABackend.security.dto.RespuestaValueDto;
import com.dacrt.SBIABackend.security.entity.Params;
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.RolesPrivilegesRepository;
import com.dacrt.SBIABackend.security.repository.UsersRepository;
import com.dacrt.SBIABackend.security.service.MenuService;
import com.dacrt.SBIABackend.security.service.ParamsService;
import com.dacrt.SBIABackend.security.service.SecurityService;
import com.dacrt.SBIABackend.security.service.UsersService;
import com.dacrt.SBIABackend.utils.HttpReqRespUtils;

@RestController
@CrossOrigin(origins = "*")
public class CoveragechannelsController {
	@Autowired
	private ParamsRepository paramsRepository;
	
	@Autowired
	private UsersRepository usersRepository;
	
	@Autowired
	private AuditRepository auditRepository;
	
	
	@Autowired
	private RolesPrivilegesRepository rolesPrivilegesRepository;
	
	@Autowired
	UsersService usersService;
	
	@Autowired
	ParamsService paramsService;
	
	@Autowired
	SecurityService securityService;
	
	@Autowired
	MenuService menuService;
	
	@Autowired
	CampaignsRepository campaignsRepository;
	
	
	@Autowired
    private JdbcTemplate jdbcTemplate;
	
	@Value("${var.ambiente}")
	private String urlAmbiente;
	
	@Value("${spring.datasource.url}")
	private String conexion;
	
	@Value("${spring.datasource.username}")
	private String userbd;
	
	@Value("${spring.datasource.password}")
	private String passbd;
	
	
	@PersistenceContext
    private EntityManager entityManager;
	
	@Autowired
	CoveragechannelshistoryRepository coveragechannelshistoryRepository;
	
	@Autowired
	CoveragechannelsRepository coveragechannelsRepository;
	
	@Autowired
	StrategiesdetRepository strategiesdetRepository;
	
	Logger logger = LoggerFactory.getLogger(CoveragechannelsController.class);

	@Transactional
	@PostMapping("/coveragechannels")
	public ResponseEntity<?> coverChannels(HttpServletRequest request,
			@RequestBody CoverageChannelsListDto coverageChannelsListDto) throws ParseException {		
		RespuestaMsgDto respuesta = new RespuestaMsgDto("");
		HttpStatus estatus = HttpStatus.FORBIDDEN;
		long cuantosregistro = 0;

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

		String searchIn = "";
		int statusIn = 0;
		int campaingIn=0;

		String searchModule = "";
		String searchUsr = "";
		String contentIn = "";
		int orderIn = 0;
		int offsetIn = 0;
		int numofrecordsIn = 0;
		int rolisvalid = 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);
		
		Long resource= 0L;
		Long positions= 0L;
		
		// Verifico la session
		if (sessionid == null) {
			respuesta.setMsg("Llamada al servicio malformado");
			estatus = HttpStatus.BAD_REQUEST;
			return new ResponseEntity(respuesta, estatus);
		} 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
				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,
						encontreSessionUsuario.get().getId());
				
				if (fechaComoCadena == "") {
					RespuestaMsgDto respuestaDto2;
					String var2 = "";
					boolean bloked2 = false;
					respuestaDto2 = new RespuestaMsgDto(var2);
					respuestaDto2.setMsg("Sesión expirada o inválida");
					return new ResponseEntity(respuestaDto2, HttpStatus.UNAUTHORIZED);
				}
				
				// Obtengo el rol de usuario y verifico si corresponde al privilegio del usuario
				rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 350);
				//rolisvalid = 3;
				if (rolisvalid == 0) {
					respuesta.setMsg("No tiene los Privilegios");
					estatus = HttpStatus.FORBIDDEN;
					return new ResponseEntity(respuesta, estatus);
				}
				
				// Obtengo los datos del Body
				searchIn = coverageChannelsListDto.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);
				  }
				  
				statusIn = coverageChannelsListDto.getFilters().getStatus();// dato de busqueda por status
				
				orderIn = coverageChannelsListDto.getOrder(); // Orden Ascedente o Descendente
				offsetIn = coverageChannelsListDto.getOffset();// Primer registro a mostrar
				numofrecordsIn = coverageChannelsListDto.getNumofrecords();// Número de registros a mostrar
				contentIn = coverageChannelsListDto.getContent();
				// Verifico los Shorcouts
				if (contentIn != null && contentIn != "")
					menuService.iscontentdiffnull(contentIn, encontreSessionUsuario.get().getId());

				try {
					Query query,query2;
					Integer idUsuario2=encontreSessionUsuario.get().getId();
					//Cantidad de procesos a evaluar																										
				
					cuantosregistro=0;
					
					//SE INSERTA EN LA coverageprocesses los registros que no tengan entrada en dicha tabla, se valida por la clave compuesta :strategiesdetunitid,strategiesdetprocessid
					
					/*String SentenciaInsert = " INSERT INTO main.coveragechannels (strategiesdetid,createdat,modifiedat)  "
							+ "							SELECT  ORI.idstrategiesdet,current_timestamp,current_timestamp "
							+ "							FROM "
							+ "					          (SELECT "
							+ "					            ed.id AS idstrategiesdet "
							+ "					           FROM  "
							+ "					             main.strategiesdet ed,main.strategies eg  where ed.channelid is not null AND ed.strategyid = eg.id and strategytypepar = 2	"
							+ "					           ) AS ORI"
							+ "					         LEFT JOIN "
							+ "					         main.coveragechannels AS DES "
							+ "					         ON "
							+ "					         ORI.idstrategiesdet = DES.strategiesdetid  "
							+"  WHERE DES.strategiesdetid IS NULL";*/
					
					String SentenciaInsert = " INSERT INTO main.coveragechannels (strategiesdetid,createdat,modifiedat)  "
							+ "							SELECT  ORI.idstrategiesdet,current_timestamp,current_timestamp "
							+ "							FROM "
							+ "					          (SELECT distinct ed.id AS idstrategiesdet  "
							+ " 							 FROM main.strategiesdet ed "
							+ " 							 JOIN main.strategies eg ON ed.strategyid = eg.id AND ed.status=1 "
							+ "                         LEFT JOIN main.strategiesdetunits s ON s.strategydetid =ed.id "
							+ "                         LEFT JOIN main.units u ON u.id=s.unitid and u.status=1 "
							+ "                         LEFT JOIN main.userunits us ON us.userid=:idUsuario AND us.unitid=u.id "
							+ "                             where ed.channelid is not null	"
							+ "					           ) AS ORI"
							+ "					         LEFT JOIN "
							+ "					         main.coveragechannels AS DES "
							+ "					         ON "
							+ "					         ORI.idstrategiesdet = DES.strategiesdetid  "
							+"  WHERE DES.strategiesdetid IS NULL";
					System.out.println(SentenciaInsert);
					query2 = entityManager.createNativeQuery(SentenciaInsert);
					query2.setParameter("idUsuario", idUsuario2);
					int cuantosregistro2 = query2.executeUpdate();
					
					//Luego query de consulta
					
					
					String QueryTotal="";
					String LowerSearch = searchIn.toLowerCase(); // se convierte en minúscula
					
					
		String SentenciaBase  = "SELECT  e.id isstrategiesdet,can.name AS canal,can.id AS idcan, "
				+ "                      e.name namestra,cov.estatus, CAST(coalesce(cov.eval,0) AS integer),cov.id idcover,eg.id idstra,CASE WHEN e.status = 1 THEN 'Activo' ELSE 'Inactiva' END AS status_estra,e.status stacod  "
				+ "              FROM main.strategiesdet e 	 "
				+ "              JOIN main.strategies eg ON e.strategyid = eg.id "
				+ "              JOIN main.channels can ON e.channelid  = can.id 	 "
				+ "              JOIN (SELECT CASE WHEN tot.eval = tot.totalestatus THEN TRUE ELSE FALSE END AS estatus,  "
				+ "                           tot.eval,tot.coveragechannelid,cover.strategiesdetid,cover.id  "
				+ "                      FROM (SELECT COUNT(1) AS eval,(SELECT COUNT(ch2.status)  "
				+ "                                                     FROM main.coveragechannelshistory ch2  "
				+ "                                                     WHERE ch2.status = 1 AND ch2.coveragechannelid = ch.coveragechannelid) AS totalestatus,  "
				+ "                                                     ch.coveragechannelid  "
				+ "                            FROM main.coveragechannelshistory ch GROUP BY ch.coveragechannelid) AS tot  "
				+ "              RIGHT JOIN (SELECT cp.strategiesdetid,cp.id  "
				+ "              FROM main.coveragechannels cp  "
				+ "              LEFT JOIN main.coveragechannelshistory ch ON ch.coveragechannelid = cp.id  "
				+ "              GROUP BY cp.strategiesdetid,cp.id  "
				+ "              ) AS cover ON tot.coveragechannelid = cover.id  "
				+ ") AS cov ON cov.strategiesdetid = e.id ";
					 	//	+ "	group by e.id,ep.id ,e.strategydetid,uu.unitid,u.name,p.name ,p.id,eg.name,cov.estatus,cov.eval,cov.id" ;
					
					if (searchIn!=null) {
						switch (searchIn) {
							case "":
								QueryTotal = SentenciaBase + " AND 1=1 ";
								break;
							default: // viene con el parametro para buscar por el like
								QueryTotal = SentenciaBase + " AND ( lower(can.name) LIKE  " + "'%" + LowerSearch + "%'" +  " OR lower(e.name) LIKE  " + "'%" + LowerSearch + "%'" + " ) "  ;
								break;
						}
					}else {
						 respuesta.setMsg("Llamada al servicio malformado");
						 estatus = HttpStatus.BAD_REQUEST;
						 return new ResponseEntity(respuesta, estatus);
				 	 }

					
						switch (statusIn) {
							case 0:
								QueryTotal = QueryTotal + " AND 1=1 ";
								break;
							case 1:
								QueryTotal = QueryTotal + " AND estatus =  true";
								break;
							case 2:
								QueryTotal = QueryTotal + " AND estatus =  false ";
								break;
							default:
								respuesta.setMsg("Llamada al servicio malformado");
								estatus = HttpStatus.BAD_REQUEST;
								return new ResponseEntity(respuesta, estatus);
						 }
					
					
					switch (orderIn) {
						case 1: // ordena por nombre de unidad
							QueryTotal = QueryTotal + " ORDER BY can.name ASC ";
							break;
	
						case 2:// ordena por nombre de proceso
							QueryTotal = QueryTotal + " ORDER BY e.name ASC ";
							break;												
	
						case -1: // ordena por nombre de unidad
							QueryTotal = QueryTotal + " ORDER BY can.name DESC  ";
							break;
	
						case -2:// ordena por nombre de proceso
							QueryTotal = QueryTotal + " ORDER BY e.name DESC ";
							break;					
	
						default:
							respuesta.setMsg("Llamada al servicio mal formado");
							estatus = HttpStatus.BAD_REQUEST;
							return new ResponseEntity(respuesta, estatus);
					}
					
					query = entityManager.createNativeQuery(QueryTotal);
					//query.setParameter("idUsuario", idUsuario2);
					cuantosregistro = (long) query.getResultList().size();
					query.setFirstResult(offsetIn);
					query.setMaxResults(numofrecordsIn);
					List<Object[]> resultados = query.getResultList();
					
				
					
					CoverageChannelsRecordDet coverageChannelsRecordDet = new CoverageChannelsRecordDet();
					CoverageChannelResponseDto coverageChannelsResponseDto = new CoverageChannelResponseDto();
					CoverageEvaluationDto  coverageEvaluationDto = new CoverageEvaluationDto();
					List<CoverageChannelsRecordDet> listRecord = new ArrayList<>();
					
					
					UnitsResponseDto unitsResponseDto = new UnitsResponseDto();
					TotalPosiResUnitsDto statusPosiResour = new TotalPosiResUnitsDto();
					OperationlineDto operationDtoChannel = new OperationlineDto();
					OperationlineDto operationDtoPro = new OperationlineDto();
					StatrategiesDetalladaDto operationDtoStr = new StatrategiesDetalladaDto();
					OperationlineDtoStatus2 operationDtoStr2 = new OperationlineDtoStatus2();
					
					ProcessResponDto processResponDto = new ProcessResponDto();
					StatusEvalUnitsResponseDto statusResponseDto= new StatusEvalUnitsResponseDto();
					PrivilegesAllDto detallePrivilege = new PrivilegesAllDto();
					TotalPosiResUnitsDto totalsResponseDto = new TotalPosiResUnitsDto();
					
					Integer contador=0;
					Integer contadorPosition=0;
					Integer contadorResource=0;
					
					
					if (cuantosregistro > 0) {
						for (Object[] fila : resultados) {
							
							coverageChannelsRecordDet.setId((int) fila[6]);
							//seteando la App
							
							operationDtoChannel.setId((int) fila[2]);
							operationDtoChannel.setName((String) fila[1]);
							
							coverageChannelsRecordDet.setChannel(operationDtoChannel);
						
							
							// seteando la estrategia
							
							operationDtoStr2.setId((int) fila[7]);
							operationDtoStr2.setName((String) fila[3]);
							operationDtoStr2.setStatus((int) fila[9]);
							
							coverageChannelsRecordDet.setStrategydet(operationDtoStr2);
							
							//seteando los datos de la evaluacion
							
							coverageEvaluationDto.setCnt((int) fila[5]);
							coverageEvaluationDto.setCompleted((boolean) fila[4]);
							coverageChannelsRecordDet.setEvaluations(coverageEvaluationDto);																			
							
							listRecord.add(coverageChannelsRecordDet);												
							statusResponseDto= new StatusEvalUnitsResponseDto();
							
							coverageChannelsRecordDet = new CoverageChannelsRecordDet();
							//coverageProcessUnitResponseDto = new CoverageProcessUnitResponseDto();
							coverageEvaluationDto = new CoverageEvaluationDto();
							operationDtoChannel = new OperationlineDto();
							// operationDtoPro = new OperationlineDto();
							 operationDtoStr = new StatrategiesDetalladaDto();
							 operationDtoStr2 = new OperationlineDtoStatus2(); 
						}
															
						
						rolisvalid=0;
						detallePrivilege = new PrivilegesAllDto();
						rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 361);
						if (rolisvalid>0)
							detallePrivilege.setUpdate(true);
						else
							detallePrivilege.setUpdate(false);

						rolisvalid=0;
						rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 360);
						if (rolisvalid>0)
							detallePrivilege.setView(true);
						else
							detallePrivilege.setView(false);

						rolisvalid=0;
						rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 362);
						if (rolisvalid>0)
							detallePrivilege.setAdd(true);
						else
							detallePrivilege.setAdd(false);

						rolisvalid=0;
						rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 363);
						if (rolisvalid>0)
							detallePrivilege.setDelete(true);
						else
							detallePrivilege.setDelete(false);
						
						coverageChannelsResponseDto.setNumofrecords(cuantosregistro);
						coverageChannelsResponseDto.setRecords(listRecord);
						coverageChannelsResponseDto.setSessionvalidthru(fechaComoCadena);
						coverageChannelsResponseDto.setPrivileges(detallePrivilege);
						
						
					}else {
						rolisvalid=0;
						detallePrivilege = new PrivilegesAllDto();
						rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 361);
						if (rolisvalid>0)
							detallePrivilege.setUpdate(true);
						else
							detallePrivilege.setUpdate(false);

						rolisvalid=0;
						rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 360);
						if (rolisvalid>0)
							detallePrivilege.setView(true);
						else
							detallePrivilege.setView(false);

						rolisvalid=0;
						rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 362);
						if (rolisvalid>0)
							detallePrivilege.setAdd(true);
						else
							detallePrivilege.setAdd(false);

						rolisvalid=0;
						rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 363);
						if (rolisvalid>0)
							detallePrivilege.setDelete(true);
						else
							detallePrivilege.setDelete(false);
						
						coverageChannelsResponseDto.setNumofrecords(cuantosregistro);
						coverageChannelsResponseDto.setRecords(listRecord);
						coverageChannelsResponseDto.setSessionvalidthru(fechaComoCadena);
						coverageChannelsResponseDto.setPrivileges(detallePrivilege);
					
					}
						
						return new ResponseEntity(coverageChannelsResponseDto, HttpStatus.OK);
				}catch(Exception e) {
					respuesta.setMsg("Error interno del servidor " + e.getMessage());
					estatus = HttpStatus.INTERNAL_SERVER_ERROR;
				}
				finally {
			        if (entityManager != null && entityManager.isOpen()) {
			            entityManager.close();
			        }
			    }
			} else { // Si la sesión que viene es inválida
				respuesta.setMsg("Sesión expirada o inválida");
				estatus = HttpStatus.BAD_REQUEST;
				return new ResponseEntity(respuesta, estatus);
			}
			return new ResponseEntity(respuesta, estatus);
		}
	}
	
	@GetMapping("/coveragechannels/{coveragechannelid}/history")
	public ResponseEntity<?> coverEvaluacionCoberturaCanal(HttpServletRequest request,
			@PathVariable("coveragechannelid") final Integer coveragechannelid) 
			throws ParseException {
		RespuestaMsgDto respuesta = new RespuestaMsgDto("");
		HttpStatus estatus = HttpStatus.FORBIDDEN;
		long cuantosregistro = 0;

		String sessionid = request.getHeader("Authorization");
		Date fecha = new Date();
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String dataFormattata = formatter.format(fecha);
		
		int offsetIn = 0;
		int numofrecordsIn = 0;
		int rolisvalid = 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);
		
		Long resource= 0L;
		Long positions= 0L;
		
			// Verifico la session
			if (sessionid == null) {
				respuesta.setMsg("Llamada al servicio malformado");
				estatus = HttpStatus.BAD_REQUEST;
				return new ResponseEntity(respuesta, estatus);
			} 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
					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,
							encontreSessionUsuario.get().getId());
					
					if (fechaComoCadena == "") {
						RespuestaMsgDto respuestaDto2;
						String var2 = "";
						boolean bloked2 = false;
						respuestaDto2 = new RespuestaMsgDto(var2);
						respuestaDto2.setMsg("Sesión expirada o inválida");
						return new ResponseEntity(respuestaDto2, HttpStatus.UNAUTHORIZED);
					}
					
					// Obtengo el rol de usuario y verifico si corresponde al privilegio del usuario
					rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 360);
					if (rolisvalid == 0) {
						respuesta.setMsg("No tiene los Privilegios");
						estatus = HttpStatus.FORBIDDEN;
						return new ResponseEntity(respuesta, estatus);
					}
					
					// Verifico si existe el id de la Evaluación de Cobertura de Canales
					Optional<Coveragechannels> obtCoverageChannels = coveragechannelsRepository.findById(coveragechannelid);
					
					// Verifico si encontre la evaluaciòn de la cobertura de canales
					if (!obtCoverageChannels.isPresent()) {
						respuesta.setMsg("Registro no encontrado");
						return new ResponseEntity(respuesta, HttpStatus.NOT_FOUND);
					}
					
					try {
						Query query,query2;
						Integer idUsuario2=encontreSessionUsuario.get().getId();
						//Cantidad de procesos a evaluar																										
					
						cuantosregistro=0;
						
						String SentenciaBase = " SELECT c.date, "
								+ "                     c.coveragestatepar, "
								+ "	                    ce.statec, "
								+ "	                    c.status, "
								+ "	                    (CASE WHEN c.status = 1 THEN 'En Proceso' ELSE 'Completada' END) AS desStatus, "
								+ "	                    c.coveragelevelpar AS idCoverage, "
								+ "	                    pr.coverage AS coverage, "
								+ "	                    c.dsc, "
								+ "	                    c.id "
								+ "              FROM main.coveragechannelshistory c "
								+ "              LEFT JOIN (SELECT elemento ->> 'dsc' AS coverage,elemento ->> 'value' AS valor FROM  "
								+ "                         main.params p,jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento  "
								+ "                         WHERE p.paramname = 'COVERAGE_LEVEL' ) pr ON c.coveragelevelpar = CAST(pr.valor AS integer) "
								+ "              LEFT JOIN (SELECT elemento ->> 'dsc' AS statec,elemento ->> 'value' AS valor FROM  "
								+ "                         main.params p,jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento  "
								+ "                         WHERE p.paramname = 'COVERAGE_STATE' ) ce ON c.coveragestatepar = CAST(ce.valor AS integer) "
								+ "              WHERE c.coveragechannelid=:coveragechannelid "
								+ "              order by 1 DESC";
						
						String SentenciaCanalEstrategia = " SELECT distinct ch.id idCanal, "
								+ "        							ch.name nombre_canal, "
								+ "	   								stp.id, "
								+ "	   								stp.name nombre_estrategia,stp.status statusestra "
								+ "							  FROM 	main.coveragechannels c, "
								+ "     							main.strategiesdet stp,  "
								+ "     							main.channels ch "
								+ "   						WHERE   c.id=:coveragechannelid "
								+ "     					  AND   c.strategiesdetid=stp.id "
								+ "	 						  AND   stp.channelid = ch.id ";
						
						query = entityManager.createNativeQuery(SentenciaBase);
						query.setParameter("coveragechannelid", coveragechannelid);
						cuantosregistro = (long) query.getResultList().size();
						query.setFirstResult(offsetIn);
						query.setMaxResults(numofrecordsIn);
						List<Object[]> resultados = query.getResultList();
						
						
						CoverageEvalChannelHistoryDto coverageEvalChannelHistoryDto= new CoverageEvalChannelHistoryDto();
						CoverageEvalChannelRecordsDto coverageEvalChannelRecordsDto = new CoverageEvalChannelRecordsDto();
						StrategiesDetDto strategiesDetDto=new StrategiesDetDto();
						OperationlineDtoStatus2 strategiesDetDto2 = new OperationlineDtoStatus2();
						
						ChannelDto channelDto = new ChannelDto();				
						List<CoverageEvalChannelRecordsDto> records= new ArrayList();
						StateDto state = new StateDto();
						StatusDto2 status = new StatusDto2();
						CoverageDto covergae = new CoverageDto();	
						
						query2 = entityManager.createNativeQuery(SentenciaCanalEstrategia);
						query2.setParameter("coveragechannelid", coveragechannelid);
						List<Object[]> resultados2 = query2.getResultList();
						
						for (Object[] fila : resultados2) {
							channelDto.setId((int) fila[0]);
							channelDto.setName((String) fila[1]);
							strategiesDetDto2.setId((int) fila[2]);
							strategiesDetDto2.setName((String) fila[3]);
							strategiesDetDto2.setStatus((int) fila[4]);
						}
						
						if (cuantosregistro > 0) {
							for (Object[] fila : resultados) {
								coverageEvalChannelRecordsDto.setId((Integer) fila[8]);
								coverageEvalChannelRecordsDto.setDate((Date) fila[0]);
								coverageEvalChannelRecordsDto.setDsc((String) fila[7]);
								state.setId((int) fila[1]);
								state.setName((String) fila[2]);
								
								status.setId((int) fila[3]);
								status.setName((String) fila[4]);
								
								covergae.setId((int) fila[5]);
								covergae.setName((String) fila[6]);
								coverageEvalChannelRecordsDto.setState(state);
								coverageEvalChannelRecordsDto.setStatus(status);
								coverageEvalChannelRecordsDto.setCoverage(covergae);
								records.add(coverageEvalChannelRecordsDto);
								
								coverageEvalChannelRecordsDto = new CoverageEvalChannelRecordsDto();
								state = new StateDto();
								status = new StatusDto2();
								covergae = new CoverageDto();	
							}
						
							
							
							coverageEvalChannelHistoryDto.setNumofrecords(cuantosregistro);
							coverageEvalChannelHistoryDto.setSessionvalidthru(fechaComoCadena);
							coverageEvalChannelHistoryDto.setCanal(channelDto);
							coverageEvalChannelHistoryDto.setStrategydet(strategiesDetDto2);
							coverageEvalChannelHistoryDto.setRecords(records);
							return new ResponseEntity(coverageEvalChannelHistoryDto, HttpStatus.OK);
						}else {
							coverageEvalChannelHistoryDto.setNumofrecords(cuantosregistro);
							coverageEvalChannelHistoryDto.setSessionvalidthru(fechaComoCadena);
							coverageEvalChannelHistoryDto.setCanal(channelDto);
							coverageEvalChannelHistoryDto.setStrategydet(strategiesDetDto2);
							coverageEvalChannelHistoryDto.setRecords(records);
							return new ResponseEntity(coverageEvalChannelHistoryDto, HttpStatus.OK);

						}
							
							
					}catch(Exception e) {
						respuesta.setMsg("Error interno del servidor " + e.getMessage());
						estatus = HttpStatus.INTERNAL_SERVER_ERROR;
					}
					finally {
				        if (entityManager != null && entityManager.isOpen()) {
				            entityManager.close();
				        }
				    }
				} else { // Si la sesión que viene es inválida
					respuesta.setMsg("Sesión expirada o inválida");
					estatus = HttpStatus.BAD_REQUEST;
					return new ResponseEntity(respuesta, estatus);
				}
				return new ResponseEntity(respuesta, estatus);
			}
	    }
	
		@GetMapping("/coveragechannels/{coveragechannelid}/history/{coveragechannelshistoryid}")
		public ResponseEntity<?> coverEvaluacionObtenerUnoChannelsHistoria(HttpServletRequest request,
				@PathVariable("coveragechannelid") final Integer coveragechannelid,
				@PathVariable("coveragechannelshistoryid") final Integer coveragechannelshistoryid)
				throws ParseException {
			RespuestaMsgDto respuesta = new RespuestaMsgDto("");
			HttpStatus estatus = HttpStatus.FORBIDDEN;
			long cuantosregistro = 0;

			String sessionid = request.getHeader("Authorization");
			Date fecha = new Date();
			SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			String dataFormattata = formatter.format(fecha);
			
			int offsetIn = 0;
			int numofrecordsIn = 0;
			int rolisvalid = 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);
			
			Long resource= 0L;
			Long positions= 0L;
			
			// Verifico la session
			if (sessionid == null) {
				respuesta.setMsg("Llamada al servicio malformado");
				estatus = HttpStatus.BAD_REQUEST;
				return new ResponseEntity(respuesta, estatus);
			} 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
					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,
							encontreSessionUsuario.get().getId());
					
					if (fechaComoCadena == "") {
						RespuestaMsgDto respuestaDto2;
						String var2 = "";
						boolean bloked2 = false;
						respuestaDto2 = new RespuestaMsgDto(var2);
						respuestaDto2.setMsg("Sesión expirada o inválida");
						return new ResponseEntity(respuestaDto2, HttpStatus.UNAUTHORIZED);
					}
					
					// Obtengo el rol de usuario y verifico si corresponde al privilegio del usuario
					rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 360);
					if (rolisvalid == 0) {
						respuesta.setMsg("No tiene los Privilegios");
						estatus = HttpStatus.FORBIDDEN;
						return new ResponseEntity(respuesta, estatus);
					}
					
					// Verifico si existe el id de la Evaluación de Cobertura de Canales
					Optional<Coveragechannels> obtCoverageChannels = coveragechannelsRepository.findById(coveragechannelid);
					
					// Verifico si encontre la evaluaciòn de la cobertura de canales
					if (!obtCoverageChannels.isPresent()) {
						respuesta.setMsg("Registro no encontrado");
						return new ResponseEntity(respuesta, HttpStatus.NOT_FOUND);
					}

					try {
						Query query,query2,query3;
						Integer idUsuario2=encontreSessionUsuario.get().getId();
						//Cantidad de procesos a evaluar																										
					
						cuantosregistro=0;
						
						String SentenciaBase = " SELECT c.id, "
								+ "                     c.date, "
								+ "                     c.coveragestatepar, "
								+ "	                    ce.statec, "
								+ "	                    c.status, "
								+ "	                    (CASE WHEN c.status = 1 THEN 'En Proceso' ELSE 'Completada' END) AS desStatus, "
								+ "	                    c.coveragelevelpar AS idCoverage, "
								+ "	                    pr.coverage AS coverage, "
								+ "	                    c.dsc "
								+ "              FROM main.coveragechannelshistory c "
								+ "              LEFT JOIN (SELECT elemento ->> 'dsc' AS coverage,elemento ->> 'value' AS valor FROM  "
								+ "                         main.params p,jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento  "
								+ "                         WHERE p.paramname = 'COVERAGE_LEVEL' ) pr ON c.coveragelevelpar = CAST(pr.valor AS integer) "
								+ "              LEFT JOIN (SELECT elemento ->> 'dsc' AS statec,elemento ->> 'value' AS valor FROM  "
								+ "                         main.params p,jsonb_array_elements(CAST(p.value AS jsonb)) AS elemento  "
								+ "                         WHERE p.paramname = 'COVERAGE_STATE' ) ce ON c.coveragestatepar = CAST(ce.valor AS integer) "
								+ "              WHERE c.coveragechannelid=:coveragechannelid "
								+ "                AND c.id=:coveragechannelshistoryid"
								+ "              order by 1 ASC";
						
						query = entityManager.createNativeQuery(SentenciaBase);
						query.setParameter("coveragechannelid", coveragechannelid);
						query.setParameter("coveragechannelshistoryid", coveragechannelshistoryid);
						cuantosregistro = (long) query.getResultList().size();
						query.setFirstResult(offsetIn);
						query.setMaxResults(numofrecordsIn);
						List<Object[]> resultados = query.getResultList();
						
						EntryCoverageChannelsDto entryCoverageChannelsDto = new EntryCoverageChannelsDto();
						EntryCoverageChannelsDto2 entryCoverageChannelsDto2 = new EntryCoverageChannelsDto2();
						StateDto state = new StateDto();
						StatusDto2 status = new StatusDto2();
						CoverageDto covergae = new CoverageDto();	
						LevelDto levelDto = new LevelDto();
						List<LevelDto> levelDtoList = new ArrayList();
						StateDetailDto stateDetailDto = new StateDetailDto();
						List<StateDetailDto> stateDetailDtoList = new ArrayList();
						String QueryLevels = "SELECT CAST(elem AS TEXT) " + "	FROM main.params pa, "
								+ "	jsonb_array_elements(CAST(pa.value AS jsonb)) AS elem "
								+ "	WHERE pa.paramname = 'COVERAGE_LEVEL' ";

						String QueryStates = "SELECT CAST(elem AS TEXT) " + "	FROM main.params pa, "
								+ "	jsonb_array_elements(CAST(pa.value AS jsonb)) AS elem "
								+ "	WHERE pa.paramname = 'COVERAGE_STATE' ";
						
						query2 = entityManager.createNativeQuery(QueryLevels);
						List<Object[]> resultadosLevels = query2.getResultList();
						
						JSONObject jsonObject;
						String jsonStringPeriod = "";
						if (resultadosLevels.size() > 0) {
							for (Object levels : resultadosLevels) {
								jsonStringPeriod = (String) levels; // Recupera el JSON como String
								jsonObject = new JSONObject(jsonStringPeriod); // Convierte String a JSONObject
								// Extrae los valores del JSONObject
								String dsc = jsonObject.getString("dsc");
								String value = jsonObject.getString("value");

								levelDto.setDsc(dsc);
								levelDto.setValue(value);
								levelDtoList.add(levelDto);
								levelDto = new LevelDto();
							}
						}
						
						query3 = entityManager.createNativeQuery(QueryStates);
						List<Object[]> resultadosStates = query3.getResultList();
						
						String jsonStringScale = "";
						if (resultadosStates.size() > 0) {
							for (Object states : resultadosStates) {
								jsonStringScale = (String) states; // Recupera el JSON como String
								jsonObject = new JSONObject(jsonStringScale); // Convierte String a JSONObject
								// Extrae los valores del JSONObject
								String dsc = jsonObject.getString("dsc");
								String value = jsonObject.getString("value");

								stateDetailDto.setDsc(dsc);
								stateDetailDto.setValue(value);
								stateDetailDtoList.add(stateDetailDto);
								stateDetailDto = new StateDetailDto();
							}
						}
						
						if (cuantosregistro > 0) {
							for (Object[] fila : resultados) {
								entryCoverageChannelsDto2.setId((int) fila[0]);
								entryCoverageChannelsDto2.setDate((Date) fila[1]);
								entryCoverageChannelsDto2.setDsc((String) fila[8]);
								state.setId((int) fila[2]);
								state.setName((String) fila[3]);
								
								status.setId((int) fila[4]);
								status.setName((String) fila[5]);
								
								covergae.setId((int) fila[6]);
								covergae.setName((String) fila[7]);
								entryCoverageChannelsDto2.setState(state);
								entryCoverageChannelsDto2.setStatus(status);
								entryCoverageChannelsDto2.setCoverage(covergae);
								
							}
							
							entryCoverageChannelsDto.setEntry(entryCoverageChannelsDto2);
							entryCoverageChannelsDto.setLevels(levelDtoList);
							entryCoverageChannelsDto.setStates(stateDetailDtoList);
							return new ResponseEntity(entryCoverageChannelsDto, HttpStatus.OK);
						}else {
							entryCoverageChannelsDto2.setId(0);
							entryCoverageChannelsDto2.setDate(null);
							entryCoverageChannelsDto2.setCoverage(null);
							entryCoverageChannelsDto2.setDsc(null);
							entryCoverageChannelsDto2.setState(null);
							entryCoverageChannelsDto2.setStatus(null);
							
							entryCoverageChannelsDto.setEntry(entryCoverageChannelsDto2);
							entryCoverageChannelsDto.setLevels(levelDtoList);
							entryCoverageChannelsDto.setStates(stateDetailDtoList);
							
							//respuesta.setMsg("Registro No Encontrado");
							estatus = HttpStatus.OK;
							return new ResponseEntity(entryCoverageChannelsDto, estatus);
						}
							
							
					}catch(Exception e) {
						respuesta.setMsg("Error interno del servidor " + e.getMessage());
						estatus = HttpStatus.INTERNAL_SERVER_ERROR;
					}
					finally {
				        if (entityManager != null && entityManager.isOpen()) {
				            entityManager.close();
				        }
				    }
				} else { // Si la sesión que viene es inválida
					respuesta.setMsg("Sesión expirada o inválida");
					estatus = HttpStatus.BAD_REQUEST;
					return new ResponseEntity(respuesta, estatus);
				}
				return new ResponseEntity(respuesta, estatus);
			}
		}
		@PostMapping({ "/coveragechannels/{coveragechannelid}/history/{coveragechannelshistoryid}" })
		public ResponseEntity<?> actualizarCoverageChannelsHistory(HttpServletRequest request,
				@RequestBody CoverageHistoryActualizarDto coverageHistoryActualizarDto,
				@PathVariable("coveragechannelid") final Integer coveragechannelid,
				@PathVariable("coveragechannelshistoryid") final Integer coveragechannelshistoryid)
				throws ParseException {
			RespuestaMsgDto respuesta = new RespuestaMsgDto("");
			HttpStatus estatus = HttpStatus.FORBIDDEN;
			long cuantosregistro = 0;

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

			String contentIn = "";
			int orderIn = 0;
			int offsetIn = 0;
			int numofrecordsIn = 0;
			int rolisvalid = 0;

			Date fecha3 = new Date();
			SimpleDateFormat formatter2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			String dataFormattata2 = formatter.format(fecha3);
			Date fechaDate2 = formatter.parse(dataFormattata2);

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

	        // Verifico la session
			if (sessionid == null) {
				respuesta.setMsg("Llamada al servicio malformado");
				estatus = HttpStatus.BAD_REQUEST;
				return new ResponseEntity(respuesta, estatus);
			} else {

				/*int statusCampaigns = campaignsRepository.findStatusCampaignByProcessId(evalprocessid);

				if (statusCampaigns == 0) {

					String var = "";
					boolean bloked = false;
					RespuestaMsgDto respuestaDto = new RespuestaMsgDto(var);
					// respuestaDto.setBlocked(bloked);
					respuestaDto.setMsg("No tiene los privilegios");
					// Error 400
					return new ResponseEntity(respuestaDto, HttpStatus.FORBIDDEN);

				}*/

				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
					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,
							encontreSessionUsuario.get().getId());

					if (fechaComoCadena == "") {
						RespuestaMsgDto respuestaDto2;
						String var2 = "";
						boolean bloked2 = false;
						respuestaDto2 = new RespuestaMsgDto(var2);
						respuestaDto2.setMsg("Sesión expirada o inválida");
						return new ResponseEntity(respuestaDto2, HttpStatus.UNAUTHORIZED);
					}

					// Obtengo el rol de usuario y verifico si corresponde al privilegio del usuario
					/*rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 201);
					if (rolisvalid == 0) {
						respuesta.setMsg("No tiene los Privilegios");
						estatus = HttpStatus.FORBIDDEN;
						return new ResponseEntity(respuesta, estatus);
					}*/

					/*if (coverageHistoryActualizarDto.getCoveragelevelpar() == null
							|| coverageHistoryActualizarDto.getRtocustomerpar() == ""
							|| coverageHistoryActualizarDto.getRtofinantialpar() == ""
							|| evalprocimpactsActualizarDto.getRtolegalpar() == ""
							|| evalprocimpactsActualizarDto.getRtooperativepar() == ""
							|| evalprocimpactsActualizarDto.getRtoreputationalpar() == ""
							|| evalprocimpactsActualizarDto.getRtoqty() == null) {
						respuesta.setMsg("Llamada al servicio malformado");
						estatus = HttpStatus.BAD_REQUEST;
						return new ResponseEntity(respuesta, estatus);
					}*/
					
					// Verifico si existe el id de la Evaluación de Cobertura de Canales
					Optional<Coveragechannels> obtCoverageChannels = coveragechannelsRepository.findById(coveragechannelid);
					
					// Verifico si encontre la evaluaciòn de la cobertura de canales
					if (!obtCoverageChannels.isPresent()) {
						respuesta.setMsg("Registro no encontrado");
						return new ResponseEntity(respuesta, HttpStatus.NOT_FOUND);
					}
					String module, Descmodule = "";
					Query query;

					try {

						if (coveragechannelshistoryid != 0) {// actualizar cobertura de canales de historia
							try {
								// verifico si tiene el privilegio
								rolisvalid = auditRepository
										.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 361);
								if (rolisvalid == 0) {
									respuesta.setMsg("No tiene los Privilegios");
									estatus = HttpStatus.FORBIDDEN;
									return new ResponseEntity(respuesta, estatus);
								}

								Optional<Strategiesdet> estrategia=strategiesdetRepository.findById(obtCoverageChannels.get().getStrategiesdetid().getId());
								if (estrategia.isPresent()){
									if (estrategia.get().getStatus()==0) {
										respuesta.setMsg("Estrategia Inactiva");
										estatus = HttpStatus.CONFLICT;
										return new ResponseEntity(respuesta, estatus);
									}
								}
								
								// Verifico si existe la cobertura de channels de historia
								Optional<Coveragechannelshistory> obtCoverageChannel = coveragechannelshistoryRepository.findByCoveragechannelhistory(coveragechannelid, coveragechannelshistoryid);
								Coveragechannelshistory coveragechannelshistory =new Coveragechannelshistory();
								Coveragechannelshistory coveragechannelshistory2 =new Coveragechannelshistory();
								// Verifico si encontre el proceso
								if (!obtCoverageChannel.isPresent()) {
									respuesta.setMsg("Registro no encontrado");
									return new ResponseEntity(respuesta, HttpStatus.NOT_FOUND);
								}
								
								if (coveragechannelshistoryRepository.existByCoveragechannelshistory(coveragechannelid, coverageHistoryActualizarDto.getDate())>0 
										&& coveragechannelshistoryRepository.findByCoveragechannelshistory(coveragechannelid, coverageHistoryActualizarDto.getDate()).get().getId()!=coveragechannelshistoryid) {
									respuesta.setMsg("Registro Duplicado");
									return new ResponseEntity(respuesta, HttpStatus.CONFLICT);
								}
								
								//verifica si la fecha es menor a la historia que tenga
								if ( coveragechannelshistoryRepository.findByCoveragechannelshistoryFecha(coveragechannelid, coverageHistoryActualizarDto.getDate()) > 0) {
									respuesta.setMsg("Llamada al servicio malformado - Fecha de Historia menor que la existente");
									estatus = HttpStatus.BAD_REQUEST;
									return new ResponseEntity(respuesta, estatus);
								}
									
								coveragechannelshistory=obtCoverageChannel.get();
								Optional<Coveragechannels> obtCoverageChannel2=coveragechannelsRepository.findById(coveragechannelid);
								coveragechannelshistory.setCoveragelevelpar(coverageHistoryActualizarDto.getCoveragelevelpar());
								coveragechannelshistory.setCoveragestatepar(coverageHistoryActualizarDto.getCoveragestatepar());
								coveragechannelshistory.setCoveragechannelid(obtCoverageChannel2.get());
								coveragechannelshistory.setModifiedat(fechaDate2);
								coveragechannelshistory.setDate(coverageHistoryActualizarDto.getDate());
								coveragechannelshistory.setStatus(coverageHistoryActualizarDto.getStatus());
								coveragechannelshistory.setDsc(coverageHistoryActualizarDto.getDsc());
								coveragechannelshistory2=coveragechannelshistoryRepository.save(coveragechannelshistory);
								// Auditoría
								module = "Cobertura de Canales";
								Descmodule = "Se actualizó la Evaluación de Coberturas de Canales de Historia: "
										+ coveragechannelshistory2.getId();
								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(fechaDate2);
								usersService.registrarAuditSesion(auditDto);

								RespuestaValueDto respuestaValueDto = new RespuestaValueDto(coveragechannelshistory2.getId());
								
								URI location = URI.create("/coveragechannels/" + coveragechannelid + "/history/" + coveragechannelshistory2.getId()); 
								return ResponseEntity.created(location).body(respuestaValueDto);

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

						} else {
							try {
								// verifico si tiene el privilegio
								rolisvalid = auditRepository
										.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(), 362);
								if (rolisvalid == 0) {
									respuesta.setMsg("No tiene los Privilegios");
									estatus = HttpStatus.FORBIDDEN;
									return new ResponseEntity(respuesta, estatus);
								}

								Optional<Strategiesdet> estrategia=strategiesdetRepository.findById(obtCoverageChannels.get().getStrategiesdetid().getId());
								if (estrategia.isPresent()){
									if (estrategia.get().getStatus()==0) {
										respuesta.setMsg("Estrategia Inactiva");
										estatus = HttpStatus.CONFLICT;
										return new ResponseEntity(respuesta, estatus);
									}
								}
								
								Optional<Coveragechannels> obtCoverageChannel=coveragechannelsRepository.findById(coveragechannelid);
								if (coveragechannelshistoryRepository.existByCoveragechannelshistory(coveragechannelid, coverageHistoryActualizarDto.getDate())>0) {
									respuesta.setMsg("Registro Duplicado");
									return new ResponseEntity(respuesta, HttpStatus.CONFLICT);
								}
								Coveragechannelshistory coveragechannelshistory =new Coveragechannelshistory();
								Coveragechannelshistory coveragechannelshistory2 =new Coveragechannelshistory();
								// Verifico si encontre el proceso
								if (!obtCoverageChannel.isPresent()) {
									respuesta.setMsg("Registro no encontrado");
									return new ResponseEntity(respuesta, HttpStatus.NOT_FOUND);
								}
								
								//verifica si la fecha es menor a la historia que tenga
								if ( coveragechannelshistoryRepository.findByCoveragechannelshistoryFecha(coveragechannelid, coverageHistoryActualizarDto.getDate()) > 0) {
									respuesta.setMsg("Llamada al servicio malformado - Fecha de Historia menor que la existente");
									estatus = HttpStatus.BAD_REQUEST;
									return new ResponseEntity(respuesta, estatus);
								}
								
								Optional<Coveragechannels> obtCoverageChannel2=coveragechannelsRepository.findById(coveragechannelid);
								coveragechannelshistory.setCoveragelevelpar(coverageHistoryActualizarDto.getCoveragelevelpar());
								coveragechannelshistory.setCoveragestatepar(coverageHistoryActualizarDto.getCoveragestatepar());
								coveragechannelshistory.setCoveragechannelid(obtCoverageChannel2.get());
								coveragechannelshistory.setModifiedat(fechaDate2);
								coveragechannelshistory.setCreatedat(fechaDate2);
								coveragechannelshistory.setDate(coverageHistoryActualizarDto.getDate());
								coveragechannelshistory.setStatus(coverageHistoryActualizarDto.getStatus());
								coveragechannelshistory.setDsc(coverageHistoryActualizarDto.getDsc());
								coveragechannelshistory2=coveragechannelshistoryRepository.save(coveragechannelshistory);
								// Auditoría
								module = "Cobertura de Canales";
								Descmodule = "Se agregó la Evaluación de Coberturas de Canales de Historia: "
										+ coveragechannelshistory2.getId();
								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(fechaDate2);
								usersService.registrarAuditSesion(auditDto);

								RespuestaValueDto respuestaValueDto = new RespuestaValueDto(coveragechannelshistory2.getId());
								
								URI location = URI.create("/coveragechannels/" + coveragechannelid + "/history/" + coveragechannelshistory2.getId()); 
								return ResponseEntity.created(location).body(respuestaValueDto);

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

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

				} else { // Si la sesión que viene es inválida
					respuesta.setMsg("Sesión expirada o inválida");
					estatus = HttpStatus.BAD_REQUEST;
					return new ResponseEntity(respuesta, estatus);
				}
				return new ResponseEntity(respuesta, estatus);
			}
		}
		
		@DeleteMapping({ "/coveragechannels/{coveragechannelid}/history/{coveragechannelshistoryid}" })
		public ResponseEntity<?> deleteCoverageHistoryChannels(HttpServletRequest request,
				@PathVariable("coveragechannelid") final Integer coveragechannelid,
				@PathVariable("coveragechannelshistoryid") final Integer coveragechannelshistoryid) throws ParseException {
			RespuestaMsgDto respuesta = new RespuestaMsgDto("");
			HttpStatus estatus = HttpStatus.FORBIDDEN;
			long cuantosregistro = 0;

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

			AuditRequestDto auditDto = new AuditRequestDto();
			String module = "";
			String Descmodule = "";

			Date fecha3 = new Date();
			SimpleDateFormat formatter2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			String dataFormattata2 = formatter.format(fecha3);
			Date fechaDate2 = formatter.parse(dataFormattata2);

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

			// Verifico la session
			if (sessionid == null) {
				respuesta.setMsg("Llamada al servicio malformado");
				estatus = HttpStatus.BAD_REQUEST;
				return new ResponseEntity(respuesta, estatus);
			} 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
					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,
							encontreSessionUsuario.get().getId());
					if (fechaComoCadena == "") {
						RespuestaMsgDto respuestaDto2;
						String var2 = "";
						boolean bloked2 = false;
						respuestaDto2 = new RespuestaMsgDto(var2);
						respuestaDto2.setMsg("Sesión expirada o inválida");
						return new ResponseEntity(respuestaDto2, HttpStatus.UNAUTHORIZED);
					}

					int rolisvalid = 0;
					try {

						// verifico si tiene el privilegio
						rolisvalid = auditRepository.getCantbyRolAndPrivi(encontreSessionUsuario.get().getRolid().getId(),
								363);
						if (rolisvalid == 0) {
							respuesta.setMsg("No tiene los Privilegios");
							estatus = HttpStatus.FORBIDDEN;
							return new ResponseEntity(respuesta, estatus);
						}
						
						Optional<Coveragechannels> obtCoverageChannel = coveragechannelsRepository.findById(coveragechannelid);
						
						// Verifico si encontre la evaluaciòn de la cobertura de procesos
						if (!obtCoverageChannel.isPresent()) {
							respuesta.setMsg("Registro no encontrado");
							return new ResponseEntity(respuesta, HttpStatus.NOT_FOUND);
						}
						
						Optional<Strategiesdet> estrategia=strategiesdetRepository.findById(obtCoverageChannel.get().getStrategiesdetid().getId());
						if (estrategia.isPresent()){
							if (estrategia.get().getStatus()==0) {
								respuesta.setMsg("Estrategia Inactiva");
								estatus = HttpStatus.CONFLICT;
								return new ResponseEntity(respuesta, estatus);
							}
						}

						Optional<Coveragechannelshistory> obtCoverageChannels = coveragechannelshistoryRepository.findByCoveragechannelhistory(coveragechannelid, coveragechannelshistoryid);
						
						// Verifico si encontre la evaluaciòn de la cobertura de procesos en la tabla de historia
						if (!obtCoverageChannels.isPresent()) {
							respuesta.setMsg("Registro no encontrado");
							return new ResponseEntity(respuesta, HttpStatus.NOT_FOUND);
						}

						try {
							coveragechannelshistoryRepository.delete(obtCoverageChannels.get());
							
							module = "Cobertura de Canales";
							Descmodule = "Se Elimino la Evaluación de Cobertura de Canales de Historia con Id: "
									+ coveragechannelshistoryid;
							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(fechaDate2);
							usersService.registrarAuditSesion(auditDto);

							RespuestaValueDto respuestaValueDto = new RespuestaValueDto(coveragechannelshistoryid);
							URI location = URI.create("/coveragechannels/" + coveragechannelid + "/history/" + coveragechannelshistoryid); 
							
							return ResponseEntity.created(location).body(respuestaValueDto);
						} catch (Exception e) {
							respuesta.setMsg("No se pudo borrar por alguna razón");
							estatus = HttpStatus.CONFLICT;
							return new ResponseEntity(respuesta, estatus);
						} finally {
							if (entityManager != null && entityManager.isOpen()) {
								entityManager.close();
							}
						}
					} catch (Exception e) {
						respuesta.setMsg("Error interno. Descripción del error " + e.getMessage());
						estatus = HttpStatus.INTERNAL_SERVER_ERROR;
						return new ResponseEntity(respuesta, estatus);
					} finally {
						if (entityManager != null && entityManager.isOpen()) {
							entityManager.close();
						}
					}
				}
				return new ResponseEntity(respuesta, HttpStatus.OK);
			}
		}
	
}
