// internal/handlers/cron_handler.go
package handlers

import (
	"context"
	"daemonService/internal/repositories"
	service "daemonService/internal/services"
	"daemonService/internal/services/procesar"
	"daemonService/internal/utils"
	"fmt"
)

type CronHandler struct {
	CuisService      *service.CuisService
	EmpresaRepo      *repositories.EmpresaRepository
	CuisRespository  *repositories.CuisRepository
	ProcesarRegistro *procesar.ProcesarRegistro
}

// Ahora recibimos también la instancia de CuisService
func NewCronHandler(
	cuisService *service.CuisService,
	empresaRepo *repositories.EmpresaRepository,
	cuisRespository *repositories.CuisRepository,
	procesarRegistro *procesar.ProcesarRegistro,
) *CronHandler {
	return &CronHandler{
		CuisService:      cuisService,
		EmpresaRepo:      empresaRepo,
		CuisRespository:  cuisRespository,
		ProcesarRegistro: procesarRegistro,
	}
}

func (s *CronHandler) ProcessCronMode(dbCtx context.Context) (interface{}, error) {
	empresasConCuis, err := s.EmpresaRepo.GetEmpresasConCuisMinimal(dbCtx)
	if err != nil {
		return nil, s.CuisService.LogError("Error al obtener empresas con CUIS: %v", err)
	}

	var lastResponse interface{}
	for _, ec := range empresasConCuis {
		s.CuisService.LogMessage("Procesando empresa ID: %d", ec.ID)

		if len(ec.Cuis) == 0 {
			s.CuisService.LogMessage("Empresa ID %d sin CUIS registrados", ec.ID)
			continue
		}

		for _, c := range ec.Cuis {
			s.CuisService.LogMessage("Procesando CUIS ID: %d", c.Cuis_id)

			cuisRequest := s.CuisService.BuildCuisRequestFromEmpresa(ec)
			respCuis, _, err := s.ProcesarRegistro.CodigoProcesarRegistro(cuisRequest)
			if err != nil {
				s.CuisService.LogError(utils.LogErrorProcessing, err, cuisRequest.CodigoSistema)
				continue
			}

			// Parsear respuesta SOAP
			codCuis, fechaVigencia, transaccion, err := utils.ParseSoapCuisResponse(respCuis)
			if err != nil {
				return nil, fmt.Errorf("error al parsear respuesta CUIS SOAP: %v", err)
			}

			// Procesamos la solicitud Cufd
			cuisRequest.Cuis = codCuis
			_, codCufd, err := s.ProcesarRegistro.CodigoProcesarRegistro(cuisRequest)
			if err != nil {
				return nil, fmt.Errorf(utils.LogErrorProcessing, cuisRequest.CodigoSistema, err)
			}

			fmt.Println("codigo CUFD: %v", codCufd)

			cufdData, err := utils.ParseSoapCufdResponse(codCufd)
			if err != nil {
				return nil, fmt.Errorf("error al parsear respuesta CUFD SOAP: %v", err)
			}

			fmt.Println("codigo CUFD: %v", cufdData)

			//if err := s.CuisRespository.ActualizarRegistro(dbCtx, ec.ID, c.Cuis_id, cuisRequest, respCuis); err != nil {
			//	s.CuisService.LogError("Error actualizando registro: %v", err)
			//	continue
			//}

			// Crear nuevo registro
			if err := s.CuisRespository.CrearNuevoRegistro(dbCtx, cuisRequest, codCuis, fechaVigencia, transaccion, cufdData); err != nil {
				//return nil, fmt.Errorf("error creando nuevo registro: %v", err)
				return nil, err
			}

			lastResponse = respCuis
		}
	}

	return lastResponse, nil
}

//package handlers
//
//import (
//	"context"
//	"daemonService/internal/repositories"
//	service "daemonService/internal/services"
//	"daemonService/internal/services/procesar"
//	"daemonService/internal/utils"
//)
//
//type CronHandler struct {
//	CuisService      *service.CuisService
//	EmpresaRepo      *repositories.EmpresaRepository
//	CuisRespository  *repositories.CuisRepository
//	ProcesarRegistro *procesar.ProcesarRegistro
//}
//
//// creamos una instancia
//func NewCronHandler(
//	empresaRepo *repositories.EmpresaRepository, cuisRespository *repositories.CuisRepository,
//	procesarRegistro *procesar.ProcesarRegistro,
//) *CronHandler {
//	return &CronHandler{
//		EmpresaRepo: empresaRepo, CuisRespository: cuisRespository,
//		ProcesarRegistro: procesarRegistro,
//	}
//}
//
//// procesa la ejecución en modo cron
//func (s *CronHandler) ProcessCronMode(dbCtx context.Context) (interface{}, error) {
//	empresasConCuis, err := s.EmpresaRepo.GetEmpresasConCuisMinimal(dbCtx)
//	if err != nil {
//		return nil, s.CuisService.LogError("Error al obtener empresas con CUIS: %v", err)
//	}
//
//	var lastResponse interface{}
//	for _, ec := range empresasConCuis {
//		s.CuisService.LogMessage("Procesando empresa ID: %d", ec.ID)
//
//		if len(ec.Cuis) == 0 {
//			s.CuisService.LogMessage("Empresa ID %d sin CUIS registrados", ec.ID)
//			continue
//		}
//
//		for _, c := range ec.Cuis {
//			s.CuisService.LogMessage("Procesando CUIS ID: %d", c.Cuis_id)
//
//			cuisRequest := s.CuisService.BuildCuisRequestFromEmpresa(ec)
//			respCuis, err := s.ProcesarRegistro.CodigoProcesarRegistro(cuisRequest, 0)
//
//			if err != nil {
//				s.CuisService.LogError(utils.LogErrorProcessing, err, cuisRequest.CodigoSistema)
//				continue
//			}
//
//			if err := s.CuisRespository.ActualizarRegistro(dbCtx, ec.ID, c.Cuis_id, cuisRequest, respCuis); err != nil {
//				s.CuisService.LogError("Error actualizando registro: %v", err)
//				continue
//			}
//
//			lastResponse = respCuis
//		}
//	}
//
//	return lastResponse, nil
//}
