// src/models/ticketSyncModel.js
const pool = require('../data/database');
const { logInfo, logError } = require('../utils/logger');

class TicketSyncModel {
    
    // Cria um registro de sincronização
    static async createSyncRecord(snTicketId, glpiTicketId = null) {
        try {
            const query = `
                INSERT INTO ticket_sync (sn_ticket_id, glpi_ticket_id)
                VALUES ($1, $2)
                RETURNING *
            `;
            const result = await pool.query(query, [snTicketId, glpiTicketId]);
            logInfo(`✅ Registro de sincronização criado para ticket SN: ${snTicketId}, GLPI: ${glpiTicketId || 'null'}`);
            return result.rows[0];
        } catch (error) {
            logError(error, `❌ Erro ao criar registro de sincronização para ticket ${snTicketId}`);
            throw error;
        }
    }

    // Atualiza o status de sincronização com o GLPI
    static async updateGlpiSyncStatus(syncId, status, glpiTicketId = null) {
        try {
            const query = `
                UPDATE ticket_sync 
                SET glpi_sync_status = $1, 
                    glpi_ticket_id = COALESCE($2, glpi_ticket_id),
                    last_glpi_sync = NOW()
                WHERE id = $3
                RETURNING *
            `;
            const result = await pool.query(query, [status, glpiTicketId, syncId]);
            logInfo(`✅ Status GLPI atualizado para: ${status}, sync ID: ${syncId}`);
            return result.rows[0];
        } catch (error) {
            logError(error, `❌ Erro ao atualizar status GLPI para sync ${syncId}`);
            throw error;
        }
    }

    // Atualiza o status de sincronização com o ServiceNow
    static async updateSnSyncStatus(syncId, status) {
        try {
            const query = `
                UPDATE ticket_sync 
                SET sn_sync_status = $1, 
                    last_sn_sync = NOW()
                WHERE id = $2
                RETURNING *
            `;
            const result = await pool.query(query, [status, syncId]);
            logInfo(`✅ Status SN atualizado para: ${status}, sync ID: ${syncId}`);
            return result.rows[0];
        } catch (error) {
            logError(error, `❌ Erro ao atualizar status SN para sync ${syncId}`);
            throw error;
        }
    }

    // Busca registro de sincronização por ticket SN
    static async findBySnTicketId(snTicketId) {
        try {
            const query = `SELECT * FROM ticket_sync WHERE sn_ticket_id = $1`;
            const result = await pool.query(query, [snTicketId]);
            return result.rows[0];
        } catch (error) {
            logError(error, `❌ Erro ao buscar sync por SN ticket ID: ${snTicketId}`);
            return null;
        }
    }

    // Busca registro de sincronização por ticket GLPI
    static async findByGlpiTicketId(glpiTicketId) {
        try {
            const query = `SELECT * FROM ticket_sync WHERE glpi_ticket_id = $1`;
            const result = await pool.query(query, [glpiTicketId]);
            return result.rows[0];
        } catch (error) {
            logError(error, `❌ Erro ao buscar sync por GLPI ticket ID: ${glpiTicketId}`);
            return null;
        }
    }

    // Busca todos os registros de sincronização com status pendente para GLPI
    static async findPendingGlpiSync() {
        try {
            const query = `
                SELECT * FROM ticket_sync 
                WHERE glpi_sync_status = 'pending'
                ORDER BY created_at
            `;
            const result = await pool.query(query);
            return result.rows;
        } catch (error) {
            logError(error, '❌ Erro ao buscar sincronizações pendentes para GLPI');
            return [];
        }
    }

    // Busca todos os registros de sincronização com status pendente para ServiceNow
    static async findPendingSnSync() {
        try {
            const query = `
                SELECT * FROM ticket_sync 
                WHERE sn_sync_status = 'pending'
                ORDER BY created_at
            `;
            const result = await pool.query(query);
            return result.rows;
        } catch (error) {
            logError(error, '❌ Erro ao buscar sincronizações pendentes para ServiceNow');
            return [];
        }
    }
}

module.exports = TicketSyncModel;