snglpi/src/services/glpiTicketService.js

const TicketSnModel = require('../models/ticketSnModel');
const TicketGlpiModel = require('../models/ticketGlpiModel');
const TicketUpdateModel = require('../models/ticketUpdateModel');
const TicketSyncModel = require('../models/ticketSyncModel');
const { logInfo, logError } = require('../utils/logger');
const { addWorkNoteToServiceNow } = require('./servicenowService');

const syncTicketsToGlpi = async () => {
    try {
        logInfo('🔄 Iniciando sincronização para GLPI...');
        const pendingTickets = await TicketSnModel.getPendingTickets();

        if (pendingTickets.length === 0) {
            logInfo('✅ Nenhum ticket pendente para sincronizar');
            return;
        }

        logInfo(`📋 Encontrados ${pendingTickets.length} tickets para sincronizar`);
        
        for (const ticket of pendingTickets) {
            await processSingleTicket(ticket);
        }

        logInfo('🎉 Sincronização com GLPI concluída!');

    } catch (error) {
        logError(error, '❌ Erro na sincronização GLPI');
        throw error;
    }
};

const processSingleTicket = async (ticket) => {
    
    try {
        logInfo(`🔍 Processando ticket: ${ticket.ticket_number}`);

        if (ticket.glpi_ticket_id) {
            logInfo(`✅ Ticket ${ticket.ticket_number} já possui GLPI ID (${ticket.glpi_ticket_id}) registrado. Apenas atualizando status.`);
            await TicketSyncModel.updateStatus(ticket.id, 'synced', 'synced');
            return;
        }

        const existingTicket = await TicketGlpiModel.ticketExists(ticket.ticket_number);
        await TicketSyncModel.updateLastSync(ticket.id, 'glpi');

        if (existingTicket) {
            logInfo(`✅ Ticket ${ticket.ticket_number} encontrado no GLPI. Atualizando registro local com o ID: ${existingTicket}`);
            
            const glpiLiveStatus = await TicketGlpiModel.getTicketStatus(existingTicket);
            if (glpiLiveStatus === 6) {
                logInfo(`Ticket GLPI ${existingTicket} já está Fechado. Marcando ticket SN ${ticket.ticket_number} como 'closed'/'ignored' e não monitorado.`);
                await TicketSyncModel.updateStatusAndGlpiTicket(ticket.id, 'ignored', 'closed', existingTicket);
                return;
            }
            await TicketSyncModel.updateStatusAndGlpiTicket(ticket.id, 'synced', 'synced', existingTicket);
            logInfo(`✅ Ticket ${ticket.ticket_number} já existe no GLPI! GLPI ID: ${existingTicket}`);
            return;
        }

        const glpiData = {
            ticket_number: ticket.ticket_number,
            short_description: ticket.short_description,
            description: ticket.description,
            justificativa: ticket.justificativa,
            caller_id: ticket.caller_id,
            caller_email: ticket.caller_email,
            caller_phone: ticket.telefone,
            caller_ramal: ticket.ramal,
            type: ticket.tipo,
            state: ticket.status,
            priority: '3',
            location_id: ticket.location_id,
            location_name: ticket.location_name,
            opened_at: ticket.opened_at,
            updated_at: ticket.updated_at
        };
        const glpiTicketId = await TicketGlpiModel.createTicket(glpiData);
        await TicketSyncModel.updateLastSync(ticket.id, 'glpi');
        await TicketSyncModel.updateStatusAndGlpiTicket(ticket.id, 'synced', 'synced', glpiTicketId);

        logInfo(`✅ Ticket ${ticket.ticket_number} sincronizado! GLPI ID: ${glpiTicketId}`);

    } catch (error) {
        logError(error, `❌ Erro no ticket ${ticket.ticket_number}`);
        try {
            await TicketSyncModel.updateStatus(ticket.id, 'error', 'collected');
        } catch (innerError) {
                logError(innerError, `❌ Erro ao registrar falha de sincronização para ticket ${ticket.id}`);
        }
    }
};

const checkGlpiStatusChanges = async () => {
    try {
        logInfo('📡 Verificando mudanças de status nos tickets do GLPI...');

        const ticketsToMonitor = await TicketSyncModel.getTicketsToMonitor();

        if (ticketsToMonitor.length === 0) {
            logInfo('Nenhum ticket ativo para verificar status no GLPI.');
            return;
        }

        for (const ticket of ticketsToMonitor) {
            const glpiStatus = await TicketGlpiModel.getTicketStatus(ticket.glpi_ticket_id);

            const currentDbStatus = ticket.glpi_sync_status;
            const glpiStatusAsString = TicketGlpiModel.mapGlpiStatusToString(glpiStatus).toLowerCase().replace(/ /g, '_');
            
            if (glpiStatus === 5 && currentDbStatus !== 'solved' && currentDbStatus !== 'closed') {
                logInfo(`Ticket GLPI ${ticket.glpi_ticket_id} foi Solucionado. Preparando para sincronização...`);
                
                const solution = await TicketGlpiModel.getTicketSolution(ticket.glpi_ticket_id);

                if (solution?.solutiontypes_id === 27) {
                    logInfo(`REGRA DETECTADA: Ticket ${ticket.glpi_ticket_id} está fora do escopo (SolutionType ID: 27).`);
                    const justification = solution?.content || 'Ticket marcado como "Fora do escopo" no GLPI.';
                    await addWorkNoteToServiceNow(ticket.sn_ticket_id, `Ticket fechado no GLPI com a justificativa: ${justification}`);
                    await TicketSyncModel.updateStatus(ticket.sn_ticket_id, 'closed', 'ignored');
                    await TicketGlpiModel.forceCloseTicket(ticket.glpi_ticket_id);
                    continue;
                }

                const sanitizedContent = solution?.content ? stripHTML(solution.content) : 'Chamado solucionado sem notas.';
                await TicketUpdateModel.insert({
                    ticket_sync_id: ticket.id,
                    source_system: 'glpi',
                    update_type: 'close_message',
                    content: sanitizedContent,
                    author: null,
                    created_at: solution?.date_mod || new Date(),
                    source_id: `solution-${ticket.glpi_ticket_id}`,
                });
                await TicketSyncModel.updateStatusAndSourceLast(ticket.sn_ticket_id, 'solved', 'pending_solve', 'GLPI');

            } else if (glpiStatus === 6 && currentDbStatus !== 'closed') {
                logInfo(`Ticket GLPI ${ticket.glpi_ticket_id} foi Fechado permanentemente. Marcando como 'closed'.`);
                await TicketSyncModel.updateStatus(ticket.sn_ticket_id, 'closed', ticket.sn_sync_status);

            } else if (glpiStatus < 5 && glpiStatusAsString !== currentDbStatus && ticket.source_last !== 'GLPI') {
                logInfo(`Mudança de status (aberto) detectada no GLPI para o ticket ${ticket.glpi_ticket_id}. De '${currentDbStatus}' para '${glpiStatusAsString}'.`);
                await TicketSyncModel.updateSourceLast(ticket.sn_ticket_id, 'GLPI');
            }
        }
    } catch (error) {
        logError(error, '🚨Falha ao verificar mudanças de status no GLPI');
    }
};

const closeTicketInGlpi = async (ticket) => {
    try {
        logInfo(`🔒 Iniciando fechamento do chamado GLPI ${ticket.glpi_ticket_id}...`);

        const closeMessageRecord = await TicketUpdateModel.getLatestUpdate(ticket.id, 'servicenow');
        const solutionContent = closeMessageRecord?.content || 'Chamado encerrado via integração com o ServiceNow.';

        await TicketGlpiModel.closeTicket(ticket.glpi_ticket_id, solutionContent);
        await TicketSyncModel.updateLastSync(ticket.sn_ticket_id, 'glpi');

        logInfo(`✅ Chamado ${ticket.glpi_ticket_id} solucionado com sucesso no GLPI.`);
    } catch (error) {
        logError(error, `🚨Falha ao fechar chamado no GLPI: ${ticket.glpi_ticket_id}`);
        throw error;
    }
};

module.exports = {
    syncTicketsToGlpi,
    checkGlpiStatusChanges,
    closeTicketInGlpi
};

/**
 * @module glpiTicketService
 * @description Este serviço contém a lógica de negócio para a criação e atualização de tickets no GLPI.
 * Ele atua como um intermediário entre os controladores e os modelos de dados.
 *
 * Principais Funcionalidades:
 * - `syncTicketsToGlpi()`: Função principal que busca tickets pendentes no banco de dados local (previamente coletados do ServiceNow) e orquestra sua criação no GLPI.
 * - `processSingleTicket(ticket)`: Processa um único ticket. Verifica se ele já existe no GLPI para evitar duplicatas. Se não existir, formata os dados (incluindo o enriquecimento da descrição para requisições) e chama o `TicketGlpiModel` para criar o ticket. Se já existir, apenas atualiza o registro de sincronização.
 * - `checkGlpiStatusChanges()`: (Atualmente não utilizado no fluxo principal, sua lógica foi integrada ao `processStatusController`) Função projetada para detectar proativamente mudanças de status no GLPI.
 * - `closeTicketInGlpi(ticket)`: Orquestra o processo de fechamento de um ticket no GLPI. Ele busca a nota de resolução vinda do ServiceNow e a utiliza para adicionar uma solução no GLPI antes de mudar o status para "Solucionado".
 */