// 🚛 Gestión de Placas - CEDAH Sistema MySQL
const { executeQuery } = require('./connection');

/**
 * Buscar una placa en la base de datos
 * @param {string} placa - Número de placa a buscar
 * @returns {Object} Información de la placa o null si no existe
 */
async function buscarPlaca(placa) {
    try {
        console.log(`🔍 Buscando placa en MySQL: ${placa}`);
        
        const sql = `
            SELECT 
                placa,
                tipo_transporte,
                vigencia,
                estatus_actual_de_unidad,
                fecha_creacion,
                fecha_actualizacion
            FROM placas 
            WHERE placa = ? 
            LIMIT 1
        `;
        
        const rows = await executeQuery(sql, [placa.toUpperCase()]);
        
        if (rows.length === 0) {
            console.log(`❌ Placa ${placa} no encontrada en MySQL`);
            return null;
        }
        
        const placaData = rows[0];
        
        // Formatear fecha de vigencia
        const vigenciaFormatted = placaData.vigencia instanceof Date 
            ? placaData.vigencia.toISOString().split('T')[0]
            : placaData.vigencia;
        
        const resultado = {
            placa: placaData.placa,
            tipo_transporte: placaData.tipo_transporte,
            vigencia: vigenciaFormatted,
            estatus_actual_de_unidad: placaData.estatus_actual_de_unidad
        };
        
        console.log(`✅ Placa ${placa} encontrada en MySQL:`, resultado);
        return resultado;
        
    } catch (error) {
        console.error(`❌ Error al buscar placa ${placa} en MySQL:`, error.message);
        throw error;
    }
}

/**
 * Insertar una nueva placa
 * @param {Object} placaData - Datos de la placa
 * @returns {Object} Placa insertada
 */
async function insertarPlaca(placaData) {
    try {
        const { placa, tipo_transporte, vigencia, estatus_actual_de_unidad } = placaData;
        
        console.log(`📝 Insertando nueva placa: ${placa}`);
        
        const sql = `
            INSERT INTO placas (placa, tipo_transporte, vigencia, estatus_actual_de_unidad)
            VALUES (?, ?, ?, ?)
        `;
        
        await executeQuery(sql, [
            placa.toUpperCase(),
            tipo_transporte,
            vigencia,
            estatus_actual_de_unidad
        ]);
        
        console.log(`✅ Placa ${placa} insertada exitosamente`);
        
        // Retornar la placa insertada
        return await buscarPlaca(placa);
        
    } catch (error) {
        if (error.code === 'ER_DUP_ENTRY') {
            console.log(`⚠️ Placa ${placaData.placa} ya existe, actualizando...`);
            return await actualizarPlaca(placaData);
        }
        
        console.error(`❌ Error al insertar placa ${placaData.placa}:`, error.message);
        throw error;
    }
}

/**
 * Actualizar una placa existente
 * @param {Object} placaData - Nuevos datos de la placa
 * @returns {Object} Placa actualizada
 */
async function actualizarPlaca(placaData) {
    try {
        const { placa, tipo_transporte, vigencia, estatus_actual_de_unidad } = placaData;
        
        console.log(`🔄 Actualizando placa: ${placa}`);
        
        const sql = `
            UPDATE placas 
            SET tipo_transporte = ?, 
                vigencia = ?, 
                estatus_actual_de_unidad = ?
            WHERE placa = ?
        `;
        
        const result = await executeQuery(sql, [
            tipo_transporte,
            vigencia,
            estatus_actual_de_unidad,
            placa.toUpperCase()
        ]);
        
        if (result.affectedRows === 0) {
            throw new Error(`Placa ${placa} no encontrada para actualizar`);
        }
        
        console.log(`✅ Placa ${placa} actualizada exitosamente`);
        
        // Retornar la placa actualizada
        return await buscarPlaca(placa);
        
    } catch (error) {
        console.error(`❌ Error al actualizar placa ${placaData.placa}:`, error.message);
        throw error;
    }
}

/**
 * Eliminar una placa
 * @param {string} placa - Número de placa a eliminar
 * @returns {boolean} True si se eliminó correctamente
 */
async function eliminarPlaca(placa) {
    try {
        console.log(`🗑️ Eliminando placa: ${placa}`);
        
        const sql = 'DELETE FROM placas WHERE placa = ?';
        const result = await executeQuery(sql, [placa.toUpperCase()]);
        
        if (result.affectedRows === 0) {
            console.log(`⚠️ Placa ${placa} no encontrada para eliminar`);
            return false;
        }
        
        console.log(`✅ Placa ${placa} eliminada exitosamente`);
        return true;
        
    } catch (error) {
        console.error(`❌ Error al eliminar placa ${placa}:`, error.message);
        throw error;
    }
}

/**
 * Obtener todas las placas con paginación
 * @param {number} limit - Límite de resultados
 * @param {number} offset - Desplazamiento
 * @returns {Array} Lista de placas
 */
async function listarPlacas(limit = 50, offset = 0) {
    try {
        console.log(`📋 Listando placas (limit: ${limit}, offset: ${offset})`);
        
        const sql = `
            SELECT 
                placa,
                tipo_transporte,
                vigencia,
                estatus_actual_de_unidad,
                fecha_creacion
            FROM placas 
            ORDER BY fecha_creacion DESC
            LIMIT ? OFFSET ?
        `;
        
        const rows = await executeQuery(sql, [limit, offset]);
        
        // Formatear fechas
        const placas = rows.map(row => ({
            placa: row.placa,
            tipo_transporte: row.tipo_transporte,
            vigencia: row.vigencia instanceof Date 
                ? row.vigencia.toISOString().split('T')[0]
                : row.vigencia,
            estatus_actual_de_unidad: row.estatus_actual_de_unidad
        }));
        
        console.log(`✅ ${placas.length} placas encontradas`);
        return placas;
        
    } catch (error) {
        console.error('❌ Error al listar placas:', error.message);
        throw error;
    }
}

/**
 * Contar total de placas
 * @returns {number} Total de placas en la base de datos
 */
async function contarPlacas() {
    try {
        const sql = 'SELECT COUNT(*) as total FROM placas';
        const rows = await executeQuery(sql);
        return rows[0].total;
    } catch (error) {
        console.error('❌ Error al contar placas:', error.message);
        throw error;
    }
}

/**
 * Buscar placas por estatus
 * @param {string} estatus - Estatus a buscar
 * @returns {Array} Lista de placas con el estatus especificado
 */
async function buscarPorEstatus(estatus) {
    try {
        console.log(`🔍 Buscando placas con estatus: ${estatus}`);
        
        const sql = `
            SELECT 
                placa,
                tipo_transporte,
                vigencia,
                estatus_actual_de_unidad
            FROM placas 
            WHERE estatus_actual_de_unidad = ?
            ORDER BY vigencia DESC
        `;
        
        const rows = await executeQuery(sql, [estatus.toUpperCase()]);
        
        const placas = rows.map(row => ({
            placa: row.placa,
            tipo_transporte: row.tipo_transporte,
            vigencia: row.vigencia instanceof Date 
                ? row.vigencia.toISOString().split('T')[0]
                : row.vigencia,
            estatus_actual_de_unidad: row.estatus_actual_de_unidad
        }));
        
        console.log(`✅ ${placas.length} placas encontradas con estatus ${estatus}`);
        return placas;
        
    } catch (error) {
        console.error(`❌ Error al buscar placas por estatus ${estatus}:`, error.message);
        throw error;
    }
}

module.exports = {
    buscarPlaca,
    insertarPlaca,
    actualizarPlaca,
    eliminarPlaca,
    listarPlacas,
    contarPlacas,
    buscarPorEstatus
};