import Swal from 'sweetalert2';
import { programarEnfoqueCampoFormulario } from '../Contratos/utils/validacionFormulario';

export interface DatosSipsFormulario {
    cups: string;
    tipoServicio: string;
    tarifa: string;
    cif: string;
    tipoTitular: string;
    titular: string;
    selectedProvinciaId: number | '';
    selectedLocalidadId: number | '';
    codigoPostal: string;
    direccion: string;
    optimizacion: string;
    ahorroMin: string;
    ahorroMax: string;
    consumoMin: string;
    consumoMax: string;
    potenciaMin: string;
    potenciaMax: string;
    vencimientoMin: string;
    vencimientoMax: string;
}

export function validarFormatoCups(cups: string): boolean {
    if (!cups.trim()) {
        return false;
    }

    const normalizado = cups.trim().toUpperCase();
    return normalizado.startsWith('ES') && normalizado.length >= 20;
}

export function mensajeErrorCups(cups: string): string {
    const valor = cups.trim();
    if (!valor) {
        return 'El CUPS es obligatorio.';
    }
    if (!valor.toUpperCase().startsWith('ES')) {
        return 'El CUPS debe comenzar con "ES".';
    }
    if (valor.length < 20) {
        return `El CUPS debe tener al menos 20 caracteres (actual: ${valor.length}).`;
    }

    return 'El CUPS no tiene un formato válido.';
}

function parseNumero(valor: string): number | null {
    if (valor.trim() === '') {
        return null;
    }

    const n = Number(valor);
    return Number.isFinite(n) ? n : null;
}

function validarRangoNumerico(
    errores: Record<string, string>,
    minKey: keyof DatosSipsFormulario,
    maxKey: keyof DatosSipsFormulario,
    etiqueta: string,
    datos: DatosSipsFormulario,
): void {
    const min = parseNumero(String(datos[minKey]));
    const max = parseNumero(String(datos[maxKey]));

    if (min !== null && max !== null && min > max) {
        errores[maxKey] = `${etiqueta} máximo debe ser mayor o igual que ${etiqueta.toLowerCase()} mínimo.`;
    }
}

export function validarConsultaSips(
    datos: Pick<DatosSipsFormulario, 'cups' | 'tipoServicio'>,
): Record<string, string> {
    const errores: Record<string, string> = {};

    if (!validarFormatoCups(datos.cups)) {
        errores.cups = mensajeErrorCups(datos.cups);
    }

    if (!datos.tipoServicio) {
        errores.tipoServicio = 'Seleccione el tipo de servicio.';
    }

    return errores;
}

export function validarFormularioDatosSuministro(datos: DatosSipsFormulario): Record<string, string> {
    const errores = validarConsultaSips(datos);

    if (datos.cif.trim() && !/^[A-Za-z0-9]{8,12}$/.test(datos.cif.trim())) {
        errores.cif = 'El CIF/NIF no tiene un formato válido.';
    }

    if (datos.selectedProvinciaId && !datos.selectedLocalidadId) {
        errores.selectedLocalidadId = 'Seleccione la localidad.';
    }

    validarRangoNumerico(errores, 'ahorroMin', 'ahorroMax', 'Ahorro', datos);
    validarRangoNumerico(errores, 'consumoMin', 'consumoMax', 'Consumo', datos);
    validarRangoNumerico(errores, 'potenciaMin', 'potenciaMax', 'Potencia', datos);

    if (datos.vencimientoMin && datos.vencimientoMax && datos.vencimientoMin > datos.vencimientoMax) {
        errores.vencimientoMax = 'La fecha de vencimiento máximo debe ser posterior o igual a la mínima.';
    }

    return errores;
}

const MAPA_IDS_DOM: Record<string, string> = {
    cups: 'sips-cups',
    tipoServicio: 'sips-tipo-servicio',
    cif: 'sips-cif',
    selectedLocalidadId: 'sips-localidad',
    ahorroMax: 'sips-ahorro-max',
    consumoMax: 'sips-consumo-max',
    potenciaMax: 'sips-potencia-max',
    vencimientoMax: 'sips-vencimiento-max',
};

const ORDEN_CAMPOS = [
    'cups',
    'tipoServicio',
    'cif',
    'selectedLocalidadId',
    'ahorroMax',
    'consumoMax',
    'potenciaMax',
    'vencimientoMax',
] as const;

export async function mostrarErroresValidacionSips(
    errores: Record<string, string>,
    titulo = 'Validación',
): Promise<void> {
    const primerCampo = ORDEN_CAMPOS.find((campo) => errores[campo]) ?? Object.keys(errores)[0];
    const mensaje = primerCampo ? errores[primerCampo] : 'Revise los campos del formulario.';

    await Swal.fire({
        title: titulo,
        text: mensaje,
        icon: 'warning',
        confirmButtonText: 'Entendido',
        returnFocus: false,
    });

    if (primerCampo) {
        programarEnfoqueCampoFormulario(MAPA_IDS_DOM[primerCampo] ?? primerCampo);
    }
}

export async function mostrarExitoSips(titulo: string, texto: string): Promise<void> {
    await Swal.fire({
        title: titulo,
        text: texto,
        icon: 'success',
        timer: 2200,
        showConfirmButton: false,
    });
}

export async function mostrarErrorSips(titulo: string, texto: string): Promise<void> {
    await Swal.fire({
        title: titulo,
        text: texto,
        icon: 'error',
        confirmButtonText: 'Entendido',
    });
}