/**
 * Servicio para consumir los endpoints de datos (CUPS y Localidades)
 * Estos datos se obtienen desde la API en lugar de props de Inertia
 */

import axios from 'axios';
import { getCached, setCached, clearCached } from './simpleCache';

// Tipos de respuesta
export interface ApiResponse<T> {
    success: boolean;
    data: T;
    count?: number;
    cached_at?: string;
    message?: string;
    error?: string;
}

/**
 * Obtiene todos los CUPS eléctricos desde la API
 */
export const getCupsElectricos = async (): Promise<ApiResponse<any[]>> => {
    try {
        const response = await axios.get('/api/data/cups-electricos');
        return response.data;
    } catch (error: any) {
        console.error('Error al obtener CUPS eléctricos:', error);
        throw error;
    }
};

/**
 * Obtiene todos los CUPS de gas desde la API
 */
export const getCupsGas = async (): Promise<ApiResponse<any[]>> => {
    try {
        const response = await axios.get('/api/data/cups-gas');
        return response.data;
    } catch (error: any) {
        console.error('Error al obtener CUPS de gas:', error);
        throw error;
    }
};


/**
 * Obtiene todos los CUPS eléctricos desde la API
 */
export const getCupsElectricosByClient = async (idCliente: number): Promise<ApiResponse<any[]>> => {
    try {
        const response = await axios.get('/api/data/cups-electricos', {
            params: { cliente: idCliente }
        });
        console.log(response);
        return response.data;
    } catch (error: any) {
        console.error('Error al obtener CUPS eléctricos:', error);
        throw error;
    }
};

export const getCupsElectricosByClientes = async (clientes: number[]): Promise<ApiResponse<any[]>> => {
    try {
        const response = await axios.get('/api/data/cups-electricos/by-clientes', {
            params: {
                clientes: clientes.join(','),
            }
        });

        return response.data;
    } catch (error: any) {
        return {
            success: false,
            message: 'Error al cargar CUPS eléctricos (bulk)',
            data: [],
            error: error?.message
        };
    }
};

/**
 * Obtiene todos los CUPS de gas desde la API
 */
export const getCupsGasByClient = async (idCliente: number): Promise<ApiResponse<any[]>> => {
    try {
        const response = await axios.get('/api/data/cups-gas', {
            params: { cliente: idCliente }
        });
        return response.data;
    } catch (error: any) {
        console.error('Error al obtener CUPS de gas:', error);
        throw error;
    }
};

export const getCupsGasByClientes = async (clientes: number[]): Promise<ApiResponse<any[]>> => {
    try {
        const response = await axios.get('/api/data/cups-gas/by-clientes', {
            params: {
                clientes: clientes.join(','),
            }
        });

        return response.data;
    } catch (error: any) {
        return {
            success: false,
            message: 'Error al cargar CUPS gas (bulk)',
            data: [],
            error: error?.message
        };
    }
};


/**
 * Obtiene todas las localidades desde la API
 */
export const getLocalidades = async (): Promise<ApiResponse<any[]>> => {
    try {
        const cacheKey = 'localidades';
        const cached = getCached<any[]>(cacheKey, 60 * 30); // 30 minutes
        if (cached) return { success: true, data: cached };

        const response = await axios.get('/api/data/localidades');
        const payload = response.data;
        try { setCached(cacheKey, payload.data || payload); } catch {}
        console.log(payload);
        return payload;
    } catch (error: any) {
        console.error('Error al obtener localidades:', error);
        throw error;
    }
};

/**
 * Obtiene una localidad específica por su ID
 */
export const getLocalidad = async (id: number): Promise<ApiResponse<any>> => {
    try {
        const cacheKey = `localidad-${id}`;
        const cached = getCached<any>(cacheKey, 60 * 30);
        if (cached) return { success: true, data: cached };

        const response = await axios.get(`/api/data/localidades/${id}`);
        const payload = response.data;
        try { setCached(cacheKey, payload.data || payload); } catch {}
        return payload;
    } catch (error: any) {
        console.error('Error al obtener localidad por id:', error);
        throw error;
    }
};

/**
 * Obtiene todas las provincias
 */
export const getProvincias = async (): Promise<ApiResponse<any[]>> => {
    try {
        const cacheKey = 'provincias';
        const cached = getCached<any[]>(cacheKey, 60 * 30); // 30 minutes
        if (cached) return { success: true, data: cached };

        const response = await axios.get(route('provincias.listar') as string);
        const payload = response.data;
        try { setCached(cacheKey, payload.data || payload); } catch {}
        return payload;
    } catch (error: any) {
        console.error('Error al obtener provincias:', error);
        throw error;
    }
};

/**
 * Obtiene provincia por clave con sus localidades
 */
export const getProvinciaConLocalidades = async (codPro: number): Promise<ApiResponse<any>> => {
    try {
        const cacheKey = `provincia-localidades-${codPro}`;
        const cached = getCached<any>(cacheKey, 60 * 30); // 30 minutes
        if (cached) return { success: true, data: cached };

        const response = await axios.get(route('provincias.clave', codPro) as string);
        const payload = response.data;
        try { setCached(cacheKey, payload.data || payload); } catch {}
        return payload;
    } catch (error: any) {
        console.error('Error al obtener provincia con localidades:', error);
        throw error;
    }
};

/**
 * Invalida el caché de CUPS eléctricos
 * Útil después de crear/editar CUPS
 */
export const refreshCupsElectricos = async (): Promise<ApiResponse<null>> => {
    try {
        const response = await axios.post('/api/data/cups-electricos/refresh');
        try { clearCached('cups-electricos'); } catch (e) { /* ignore */ }
        return response.data;
    } catch (error: any) {
        console.error('Error al refrescar CUPS eléctricos:', error);
        throw error;
    }
};

/**
 * Invalida el caché de CUPS de gas
 * Útil después de crear/editar CUPS
 */
export const refreshCupsGas = async (): Promise<ApiResponse<null>> => {
    try {
        const response = await axios.post('/api/data/cups-gas/refresh');
        try { clearCached('cups-gas'); } catch (e) { /* ignore */ }
        return response.data;
    } catch (error: any) {
        console.error('Error al refrescar CUPS de gas:', error);
        throw error;
    }
};

/**
 * Invalida el caché de localidades
 * Útil después de crear/editar localidades
 */
export const refreshLocalidades = async (): Promise<ApiResponse<null>> => {
    try {
        const response = await axios.post('/api/data/localidades/refresh');
        try { clearCached('localidades'); } catch (e) { /* ignore */ }
        return response.data;
    } catch (error: any) {
        console.error('Error al refrescar localidades:', error);
        throw error;
    }
};

/**
 * Obtiene clientes activos desde la API (búsqueda dinámica)
 */
export const getClientes = async (query?: string): Promise<ApiResponse<any[]>> => {
    try {
        // Si hay query, usamos el parámetro q.
        // El backend ahora requiere q >= 3 chars para devolver datos, o devuelve array vacío.
        const params: any = {};
        if (query) params.q = query;

        const response = await axios.get('/api/data/clientes/load-cups', { params });
        console.log('dataservice->response->getClientes', response);
        console.log('params', response);
        console.log('query', query);
        return response.data;
    } catch (error: any) {
        console.error('Error al obtener clientes:', error);
        throw error;
    }
};

/**
 * Búsqueda incremental de clientes (mínimo 3 caracteres)
 */
export const searchClientesOptimizacion = async (query: string): Promise<ApiResponse<any[]>> => {
    try {
        const response = await axios.get('/api/data/clientes', {
            params: { q: query }
        });
        return response.data;
    } catch (error: any) {
        console.error('Error al buscar clientes:', error);
        throw error;
    }
};

/**
 * Obtiene el detalle completo de un cliente por ID
 */
export const getClienteDetalle = async (idCliente: number, refresh: boolean = false): Promise<ApiResponse<any>> => {
    try {
        const response = await axios.get(`/api/data/clientes/${idCliente}`, {
            params: refresh ? { refresh: 1, _ts: Date.now() } : undefined,
        });
        return response.data;
    } catch (error: any) {
        console.error('Error al obtener detalle de cliente:', error);
        throw error;
    }
};

/**
 * Obtiene todos los contactos desde la API
 */
export const getContactos = async (): Promise<ApiResponse<any[]>> => {
    try {
        const response = await axios.get('/api/data/contactos');
        return response.data;
    } catch (error: any) {
        console.error('Error al obtener contactos:', error);
        throw error;
    }
};

/**
 * Obtiene catálogo de bancos para cuentas bancarias
 */
export const getBancos = async (): Promise<ApiResponse<any[]>> => {
    try {
        const cacheKey = 'bancos';
        const cached = getCached<any[]>(cacheKey, 60 * 30); // 30 minutes
        if (cached) return { success: true, data: cached };

        const response = await axios.get('/api/data/bancos');
        const payload = response.data;
        try { setCached(cacheKey, payload.data || payload); } catch {}
        return payload;
    } catch (error: any) {
        console.error('Error al obtener bancos:', error);
        throw error;
    }
};

/**
 * Invalida el caché de clientes
 * Útil después de crear/editar clientes
 */
export const refreshClientes = async (): Promise<ApiResponse<null>> => {
    try {
        const response = await axios.post('/api/data/clientes/refresh');
        try { clearCached('clientes'); } catch (e) { /* ignore */ }
        return response.data;
    } catch (error: any) {
        console.error('Error al refrescar clientes:', error);
        throw error;
    }
};

/**
 * Invalida el caché de contactos
 * Útil después de crear/editar contactos
 */
export const refreshContactos = async (): Promise<ApiResponse<null>> => {
    try {
        const response = await axios.post('/api/data/contactos/refresh');
        return response.data;
    } catch (error: any) {
        console.error('Error al refrescar contactos:', error);
        throw error;
    }
};

/**
 * Invalida el caché de tarifas eléctricas
 */
export const refreshTarifasElectricas = async (): Promise<ApiResponse<null>> => {
    try {
        const response = await axios.post('/api/data/tarifas-electrica/refresh');
        try { clearCached('tarifas-electrica'); } catch (e) { /* ignore */ }
        return response.data;
    } catch (error: any) {
        console.error('Error al refrescar tarifas eléctricas:', error);
        throw error;
    }
};

/**
 * Invalida el caché de tarifas de gas
 */
export const refreshTarifasGas = async (): Promise<ApiResponse<null>> => {
    try {
        const response = await axios.post('/api/data/tarifas-gas/refresh');
        try { clearCached('tarifas-gas'); } catch (e) { /* ignore */ }
        return response.data;
    } catch (error: any) {
        console.error('Error al refrescar tarifas de gas:', error);
        throw error;
    }
};

/**
 * Hook personalizado para React que obtiene datos con estado de carga
 */
export const useDataApi = () => {
    return {
        getCupsElectricos,
        getCupsGas,
        getLocalidades,
        getProvincias,
        getProvinciaConLocalidades,
        getClientes,
        getClienteDetalle,
        searchClientesOptimizacion,
        getContactos,
        getBancos,
        refreshCupsElectricos,
        refreshCupsGas,
        refreshLocalidades,
        refreshClientes,
        refreshContactos,
        refreshTarifasElectricas,
        refreshTarifasGas,
    };
};

export default {
    getCupsElectricos,
    getCupsGas,
    getLocalidades,
    getProvincias,
    getProvinciaConLocalidades,
    getClientes,
    getClienteDetalle,
    searchClientesOptimizacion,
    getContactos,
    getBancos,
    refreshCupsElectricos,
    refreshCupsGas,
    refreshLocalidades,
    refreshClientes,
    refreshContactos,
    refreshTarifasElectricas,
    refreshTarifasGas,
};