siat_codigos_service_test.go

package services_test

import (
	"context"

	"log"
	"os"
	"testing"
	"time"

	"github.com/joho/godotenv"
	"github.com/ron86i/go-siat/pkg/models"
	"github.com/ron86i/go-siat/pkg/utils"

	"github.com/ron86i/go-siat"

	"github.com/stretchr/testify/assert"
)

// TestNotificaCertificadoRevocado valida que el servicio sea capaz de informar al SIAT
// sobre la revocación de un certificado digital.
// Requisitos: El certificado enviado debe ser el registrado previamente en el portal de Impuestos.
func TestNotificaCertificadoRevocado(t *testing.T) {
	// Cargar configuración de integración desde el entorno (.env)
	godotenv.Load()

	// Parsear el NIT (Int64)
	nit, err := utils.ParseInt64Safe(os.Getenv("SIAT_NIT"))
	if err != nil {
		t.Fatalf("la variable SIAT_NIT debe ser un número válido: %v", err)
	}
	codAmbiente, err := utils.ParseIntSafe(os.Getenv("SIAT_CODIGO_AMBIENTE"))
	if err != nil {
		t.Fatalf("la variable SIAT_CODIGO_AMBIENTE debe ser un número válido: %v", err)
	}
	config := siat.Config{
		Token: os.Getenv("SIAT_TOKEN"),
	}

	siatClient, _ := siat.New(os.Getenv("SIAT_URL"), nil)
	service := siatClient.Codigos()
	fechaRevocacion := time.Now()
	// Preparar la solicitud de notificación. Se requiere un certificado y una razón válida.
	req := models.Codigos().NewNotificaCertificadoRevocadoBuilder().
		WithCodigoAmbiente(codAmbiente).
		WithCodigoSistema(os.Getenv("SIAT_CODIGO_SISTEMA")).
		WithNit(nit).
		WithCodigoSucursal(0).
		WithCuis("197C8240").
		WithFechaRevocacion(&fechaRevocacion).
		WithRazonRevocacion("Prueba de revocación por sistema").
		WithCertificado(`-----BEGIN CERTIFICATE-----
MIIEejCCA2KgA...alF2Tw0jIVieaeefsL78Yv8fA==
-----END CERTIFICATE-----`).
		Build()

	// Ejecutar la petición al SIAT y procesar el resultado de la revocación
	resp, err := service.NotificaCertificadoRevocado(context.Background(), config, req)

	// Validar que no existan errores de comunicación o de estructura SOAP
	if !assert.NoError(t, err) {
		t.Fatalf("Fallo en la comunicación con el SIAT: %v", err)
	}

	// Verificar la integridad de la respuesta y registrar el estado devuelto
	if assert.NotNil(t, resp) {
		resultado := resp.Body.Content.RespuestaNotificaRevocado
		log.Printf("Resultado de Notificación Revocada: %v", resultado.Transaccion)

		if len(resultado.MensajesList) > 0 {
			for _, msg := range resultado.MensajesList {
				log.Printf("Mensaje SIAT [%d]: %s", msg.Codigo, msg.Descripcion)
			}
		}

		// En integración, validamos que la transacción sea reportada por el SIAT
		assert.IsType(t, true, resultado.Transaccion)
	}
}

// TestVerificarNit valida el flujo completo de verificación de un NIT directamente
// contra el servicio real del SIAT, asegurando que la configuración cargada sea válida
// y que la respuesta del servidor se procese correctamente sin predecir mensajes fijos.
func TestVerificarNit(t *testing.T) {
	// Cargar configuración de integración desde el entorno (.env)
	godotenv.Load()

	codModalidad, err := utils.ParseIntSafe(os.Getenv("SIAT_CODIGO_MODALIDAD"))
	if err != nil {
		t.Fatalf("la variable SIAT_CODIGO_MODALIDAD debe ser un número válido: %v", err)
	}

	nit, err := utils.ParseInt64Safe(os.Getenv("SIAT_NIT"))
	if err != nil {
		t.Fatalf("la variable SIAT_NIT debe ser un número válido: %v", err)
	}
	codAmbiente, err := utils.ParseIntSafe(os.Getenv("SIAT_CODIGO_AMBIENTE"))
	if err != nil {
		t.Fatalf("la variable SIAT_CODIGO_AMBIENTE debe ser un número válido: %v", err)
	}
	config := siat.Config{
		Token: os.Getenv("SIAT_TOKEN"),
	}

	siatClient, _ := siat.New(os.Getenv("SIAT_URL"), nil)
	service := siatClient.Codigos()

	// Preparar la solicitud de verificación. El CUIS debe ser válido para el NIT en ambiente de prueba.
	req := models.Codigos().NewVerificarNitBuilder().
		WithCodigoAmbiente(codAmbiente).
		WithCodigoModalidad(codModalidad).
		WithCodigoSistema(os.Getenv("SIAT_CODIGO_SISTEMA")).
		WithNit(nit).
		WithCodigoSucursal(0).
		WithCuis("197C8240").
		WithNitParaVerificacion(12345678). // Un NIT de prueba para validar la comunicación
		Build()

	// Ejecutar la petición al SIAT y procesar el resultado
	resp, err := service.VerificarNit(context.Background(), config, req)

	// Validar que no existan errores de comunicación o de serialización XML
	if !assert.NoError(t, err) {
		t.Fatalf("Fallo en la comunicación con el SIAT: %v", err)
	}

	// Verificar la integridad de la respuesta y registrar los mensajes devueltos por el servidor
	if assert.NotNil(t, resp) {
		resultado := resp.Body.Content.RespuestaVerificarNit
		log.Printf("Resultado de Verificación NIT: %v", resultado.Transaccion)

		if len(resultado.MensajesList) > 0 {
			for _, msg := range resultado.MensajesList {
				log.Printf("Mensaje SIAT [%d]: %s", msg.Codigo, msg.Descripcion)
			}
		}

		// En integración, validamos que el tipo de datos sea el esperado para la transacción
		assert.IsType(t, true, resultado.Transaccion)
	}
}

// TestSolicitudCuis valida la obtención de un Código Único de Inicio de Sistemas (CUIS).
// El CUIS es fundamental para identificar un punto de venta y su sistema asociado ante el SIAT.
// Se recomienda renovar el CUIS periódicamente según la vigencia devuelta por el servidor.
func TestSolicitudCuis(t *testing.T) {
	godotenv.Load()
	codModalidad, err := utils.ParseIntSafe(os.Getenv("SIAT_CODIGO_MODALIDAD"))
	if err != nil {
		t.Fatalf("la variable SIAT_CODIGO_MODALIDAD debe ser un número válido: %v", err)
	}

	// Parsear el NIT (Int64)
	nit, err := utils.ParseInt64Safe(os.Getenv("SIAT_NIT"))
	if err != nil {
		t.Fatalf("la variable SIAT_NIT debe ser un número válido: %v", err)
	}
	codAmbiente, err := utils.ParseIntSafe(os.Getenv("SIAT_CODIGO_AMBIENTE"))
	if err != nil {
		t.Fatalf("la variable SIAT_CODIGO_AMBIENTE debe ser un número válido: %v", err)
	}
	config := siat.Config{
		Token: os.Getenv("SIAT_TOKEN"),
	}
	siatClient, _ := siat.New(os.Getenv("SIAT_URL"), nil)
	service := siatClient.Codigos()

	req := models.Codigos().NewCuisBuilder().
		WithCodigoAmbiente(codAmbiente).
		WithCodigoModalidad(codModalidad).
		WithCodigoSistema(os.Getenv("SIAT_CODIGO_SISTEMA")).
		WithNit(nit).
		WithCodigoSucursal(0).
		WithCodigoPuntoVenta(0).
		Build()

	resp, err := service.SolicitudCuis(context.Background(), config, req)

	// Confirmar que la comunicación fue exitosa y se recibió un objeto de respuesta
	if assert.NoError(t, err) && assert.NotNil(t, resp) {
		resultado := resp.Body.Content.RespuestaCuis

		// Registrar los datos obtenidos para facilitar la auditoría de los tests
		log.Printf("Respuesta Cuis - Transacción: %v", resultado.Transaccion)

		assert.NotEmpty(t, resultado.Codigo)
		log.Printf("CUIS Obtenido: %s", resultado.Codigo)
	}
}

// TestSolicitudCufd valida la obtención del Código Único de Facturación Diaria (CUFD).
// El CUFD debe solicitarse cada 24 horas o al inicio de operaciones del día.
// Requiere un CUIS vigente para ser procesado correctamente por el SIAT.
func TestSolicitudCufd(t *testing.T) {
	// Cargar entorno de configuración para tests de integración
	godotenv.Load()

	codModalidad, err := utils.ParseIntSafe(os.Getenv("SIAT_CODIGO_MODALIDAD"))
	if err != nil {
		t.Fatalf("la variable SIAT_CODIGO_MODALIDAD debe ser un número válido: %v", err)
	}

	// Parsear el NIT (Int64)
	nit, err := utils.ParseInt64Safe(os.Getenv("SIAT_NIT"))
	if err != nil {
		t.Fatalf("la variable SIAT_NIT debe ser un número válido: %v", err)
	}
	codAmbiente, err := utils.ParseIntSafe(os.Getenv("SIAT_CODIGO_AMBIENTE"))
	if err != nil {
		t.Fatalf("la variable SIAT_CODIGO_AMBIENTE debe ser un número válido: %v", err)
	}
	config := siat.Config{
		Token: os.Getenv("SIAT_TOKEN"),
	}
	siatClient, _ := siat.New(os.Getenv("SIAT_URL"), nil)
	service := siatClient.Codigos()

	req := models.Codigos().NewCuisBuilder().
		WithCodigoAmbiente(codAmbiente).
		WithCodigoModalidad(codModalidad).
		WithCodigoSistema(os.Getenv("SIAT_CODIGO_SISTEMA")).
		WithNit(nit).
		WithCodigoSucursal(0).
		WithCodigoPuntoVenta(0).
		Build()

	respCuis, err := service.SolicitudCuis(context.Background(), config, req)

	// Preparar la estructura de solicitud de CUFD con los datos de prueba
	reqCufd := models.Codigos().NewCufdBuilder().
		WithCodigoAmbiente(codAmbiente).
		WithCodigoModalidad(codModalidad).
		WithCodigoSistema(os.Getenv("SIAT_CODIGO_SISTEMA")).
		WithNit(nit).
		WithCodigoSucursal(0).
		WithCodigoPuntoVenta(0).
		WithCuis(respCuis.Body.Content.RespuestaCuis.Codigo). // Requiere un CUIS vigente para el NIT configurado
		Build()

	// Ejecutar la llamada al servicio de códigos del SIAT
	resp, err := service.SolicitudCufd(context.Background(), config, reqCufd)

	// Validar la recepción de la respuesta y registrar el estado de la transacción
	if assert.NoError(t, err) && assert.NotNil(t, resp) {
		res := resp.Body.Content.RespuestaCufd

		log.Println("Respuesta de cufd:", res)
	}
}

// TestSolicitudCufdMasivo verifica la obtención masiva de códigos CUFD para múltiples
// puntos de venta o sucursales en una sola operación.
func TestSolicitudCufdMasivo(t *testing.T) {
	// Cargar configuración de integración real
	godotenv.Load()

	codModalidad, err := utils.ParseIntSafe(os.Getenv("SIAT_CODIGO_MODALIDAD"))
	if err != nil {
		t.Fatalf("la variable SIAT_CODIGO_MODALIDAD debe ser un número válido: %v", err)
	}

	codAmbiente, err := utils.ParseIntSafe(os.Getenv("SIAT_CODIGO_AMBIENTE"))
	if err != nil {
		t.Fatalf("la variable SIAT_CODIGO_AMBIENTE debe ser un número válido: %v", err)
	}
	nit, err := utils.ParseInt64Safe(os.Getenv("SIAT_NIT"))
	if err != nil {
		t.Fatalf("la variable SIAT_NIT debe ser un número válido: %v", err)
	}
	config := siat.Config{
		Token: os.Getenv("SIAT_TOKEN"),
	}
	siatClient, err := siat.New(os.Getenv("SIAT_URL"), nil)
	assert.NoError(t, err)
	service := siatClient.Codigos()

	cuis := []*models.SolicitudListaCufdDtoBuilder{}
	cuis = append(cuis, models.Codigos().NewSolicitudListaCufdDtoBuilder().
		WithCodigoSucursal(0).
		WithCodigoPuntoVenta(0).
		WithCuis("197C8240"))
	// Configurar la lista de solicitudes masivas (por ejemplo, para la sucursal 0 y punto de venta 0)
	req := models.Codigos().NewCufdMasivoBuilder().
		WithCodigoAmbiente(codAmbiente).
		WithCodigoModalidad(codModalidad).
		WithCodigoSistema(os.Getenv("SIAT_CODIGO_SISTEMA")).
		WithNit(nit).
		WithDatosSolicitud(cuis...).
		Build()

	// Ejecutar la petición masiva al SIAT
	resp, err := service.SolicitudCufdMasivo(context.Background(), config, req)

	// Validar que la respuesta contenga datos y registrar el resultado de la operación masiva
	if assert.NoError(t, err) && assert.NotNil(t, resp) {
		res := resp.Body.Content.RespuestaCufdMasivo
		log.Printf("Resultado Masivo - Transacción: %v", res.Transaccion)

		if len(res.ListaRespuestasCufd) > 0 {
			for _, item := range res.ListaRespuestasCufd {
				log.Printf("CUFD Masivo Recibido para Sucursal %d: %v", *item.CodigoSucursal.Value, item)
			}
		}
	}
}

// TestSolicitudCuisMasivo verifica la obtención masiva de códigos CUIS para múltiples
// puntos de venta en una única transacción, asegurando la eficiencia en configuraciones extensas.
func TestSolicitudCuisMasivo(t *testing.T) {
	// Cargar configuración real del entorno para pruebas de integración
	godotenv.Load()

	codModalidad, err := utils.ParseIntSafe(os.Getenv("SIAT_CODIGO_MODALIDAD"))
	if err != nil {
		t.Fatalf("la variable SIAT_CODIGO_MODALIDAD debe ser un número válido: %v", err)
	}

	// Parsear el NIT (Int64)
	nit, err := utils.ParseInt64Safe(os.Getenv("SIAT_NIT"))
	if err != nil {
		t.Fatalf("la variable SIAT_NIT debe ser un número válido: %v", err)
	}
	codAmbiente, err := utils.ParseIntSafe(os.Getenv("SIAT_CODIGO_AMBIENTE"))
	if err != nil {
		t.Fatalf("la variable SIAT_CODIGO_AMBIENTE debe ser un número válido: %v", err)
	}
	config := siat.Config{
		Token: os.Getenv("SIAT_TOKEN"),
	}
	siatClient, _ := siat.New(os.Getenv("SIAT_URL"), nil)
	service := siatClient.Codigos()
	assert.NoError(t, err)

	listCuis := []*models.SolicitudListaCuisDtoBuilder{}
	listCuis = append(listCuis, models.Codigos().NewSolicitudListaCuisDtoBuilder().
		WithCodigoSucursal(0).
		WithCodigoPuntoVenta(0))
	// Configurar la solicitud masiva de CUIS para un punto de venta específico
	req := models.Codigos().NewCuisMasivoBuilder().
		WithCodigoAmbiente(codAmbiente).
		WithCodigoModalidad(codModalidad).
		WithCodigoSistema(os.Getenv("SIAT_CODIGO_SISTEMA")).
		WithNit(nit).
		WithDatosSolicitud(listCuis...).
		Build()

	// Ejecutar la petición masiva al SIAT
	resp, err := service.SolicitudCuisMasivo(context.Background(), config, req)

	// Validar que la comunicación fue exitosa y registrar los resultados individuales obtenidos
	if assert.NoError(t, err) && assert.NotNil(t, resp) {
		res := resp.Body.Content.RespuestaCuisMasivo
		log.Printf("Resultado Cuis Masivo - Transacción: %v", res.Transaccion)

		if len(res.ListaRespuestasCuis) > 0 {
			for _, item := range res.ListaRespuestasCuis {
				log.Printf("CUIS Masivo Recibido para Sucursal %d: %s", *item.CodigoSucursal, item.Codigo)
			}
		}
	}
}

// TestVerificarComunicacion valida la conectividad básica con los servidores del SIAT enviando una solicitud
// de verificación de comunicación. El servicio debe registrar la petición y retornar un código
// que confirme la recepción exitosa, asegurando que el canal SOAP esté operativo.
func TestVerificarComunicacion(t *testing.T) {
	// Cargar configuración desde .env
	godotenv.Load()

	config := siat.Config{
		Token: os.Getenv("SIAT_TOKEN"),
	}
	siatClient, err := siat.New(os.Getenv("SIAT_URL"), nil)
	if err != nil {
		t.Fatalf("Error al crear cliente SIAT: %v", err)
	}
	service := siatClient.Codigos()

	ctx := context.Background()
	req := models.Codigos().NewVerificarComunicacionCodigosBuilder().Build()

	// Ejecutar la petición de verificación de comunicación
	resp, err := service.VerificarComunicacion(ctx, config, req)
	if err != nil {
		t.Fatalf("Error en VerificarComunicacion: %v", err)
	}

	assert.NotNil(t, resp, "La respuesta no debería ser nula")
	assert.True(t, resp.Body.Content.RespuestaComunicacion.Transaccion, "La prueba de comunicación debería ser exitosa")
}