// src/services/servicenowService.js
const axios = require('axios');
const apiConfig = require('../../config/apiConfig');
const fs = require('fs');
const TicketSnModel = require('../models/ticketSnModel');
const { logInfo, logError, logSync } = require('../utils/logger'); 
const TicketUpdateModel = require('../models/ticketUpdateModel');

const fetchTicketsFromServiceNow = async () => {
    try {
        logInfo('📡 Buscando incidentes do ServiceNow...', { service: 'servicenow' });

        const ticketsResponse = await axios.get(apiConfig.snIncidentConfig.baseUrl, {
            auth: apiConfig.servicenowAuthentication.auth
        });
        
        // comentado para evitar muitos arquivos
        //fs.writeFileSync('servicenow_tickets.json', JSON.stringify(ticketsResponse.data, null, 2));
        //logInfo('💾 Backup JSON de incidentes salvo', { count: ticketsResponse.data.result.length });

        // Salvar os tickets no banco de dados
        logInfo('💾 Iniciando salvamento de incidentes no banco...');
        for (const ticket of ticketsResponse.data.result) {
            await TicketSnModel.saveTicket(ticket, 'incidente');
        }

        logSync('ServiceNow', ticketsResponse.data.result.length, 'incidentes');

    } catch (error) {
        logError(error, 'SERVICE NOW Tickets');
    }
}

const fetchRequestsFromServiceNow = async () => {
    try {
        logInfo('📡 Buscando requisições do ServiceNow...', { service: 'servicenow' });

        const requestsResponse = await axios.get(apiConfig.snRequestConfig.baseUrl, {
            auth: apiConfig.servicenowAuthentication.auth
        });

        // Comentado para evitar muitos arquivos
        //fs.writeFileSync('servicenow_requests.json', JSON.stringify(requestsResponse.data, null, 2));
        //logInfo('💾 Backup JSON de requisições salvo', { count: requestsResponse.data.result.length });

        // Salvar as requisições no banco de dados
        logInfo('💾 Iniciando salvamento de requisições no banco...');
        for (const request of requestsResponse.data.result) {
            await TicketSnModel.saveTicket(request, 'requisicao');
        }

        logSync('ServiceNow', requestsResponse.data.result.length, 'requisições');

    } catch (error) {
        logError(error, 'SERVICE NOW Requests');
    }
}

// Função para obter o sys_id de um ticket pela tabela de sincronização do banco de dados local

const getTicketSysId = async (ticketId) => {
    try {
        const ticket = await TicketSnModel.findById(ticketId);
        return ticket.sys_id;
    } catch (error) {
        logError(error, '🚨Falha ao obter sys_id do ticket');
        return null;
    }
}

const getTicketTypeById = async (ticketId) => {
    try {
        const ticket = await TicketSnModel.findById(ticketId);
        const ticketType = ticket.tipo;
        logInfo(`⚠️ Tipo do ticket ${ticketId} - Tipo: ${ticketType}`, { ticketId, ticketType });
        return ticketType;
    } catch (error) {
        logError(error, '🚨Falha ao obter tipo do ticket');
        return null;
    }
}

// Função para obter o código de um comentário dentro de um ticket do ServiceNow
const getCommentId = async (sysId, comment) => {
    try {
        // Exemplo de requisição GET para buscar comentários:

        // GET https://caoadev.service-now.com/api/now/table/sys_journal_field?sysparm_query=element_id=<SYS_ID_DO_INCIDENTE>^element=comments^ORDERBYDESCsys_created_on&sysparm_fields=sys_id,element,value,sys_created_on,sys_created_by,element_id&sysparm_limit=1

        // exemplo de resposta da API: 
        /*
        "result": [
        {
            "sys_id": "SYS_ID_DO_COMENTARIO",
            "sys_created_on": "2025-10-02 12:24:19",
            "element_id": "SYS_ID_DO_INCIDENTE",
            "value": "Teste fora do código",
            "sys_created_by": "SOTHIS.CAOA",
            "element": "comments"
        }*/

        const url = `${apiConfig.snTableJournalConfig.baseUrl}?sysparm_query=element_id=${sysId}^element=comments^ORDERBYDESCsys_created_on&sysparm_fields=sys_id,element,value,sys_created_on,sys_created_by,element_id`;

        const response = await axios.get(url, {
            auth: apiConfig.servicenowAuthentication.auth
        });

        const data = response.data;
        const comments = data.result;

        // Procurar o comentário exato na lista retornada
        for (const item of comments) {
            if (item.value && item.value.includes(comment)) {
                return item.sys_id; // Retorna o sys_id do comentário encontrado
            }
        }

    } catch (error) {
        logError(error, '🚨Falha ao obter ID do comentário no ServiceNow');
        return null;
    }
}

// Função para criar um comentário em um ticket no ServiceNow
const createCommentInServiceNow = async (sysId, comment, ticketType) => {
    try {
        // Exemplo de requisição PATCH para atualizar um ticket: 
        // curl -u user:pass \ 
        // -H "Content-Type: application/json" \ 
        // -X PATCH "https://SEU_INSTANCE.service-now.com/api/now/table/incident/{SYS_ID_DO_INCIDENTE}" \ 
        // -d '{"comments":"Estamos analisando seu chamado. Retorno em breve."}'
        let url = '';
        let payload = {};
        if (ticketType == 'incidente') {
            url = `${apiConfig.snTableIncidentConfig.baseUrl}${sysId}`;
            payload = {
                comments: comment
            };
        } else if (ticketType == 'requisicao') {
            url = `${apiConfig.snTableRequestConfig.baseUrl}${sysId}`;
            payload = {
                comments: comment
            };
        } else {
            logError(`Tipo de ticket desconhecido: ${ticketType}`, { sysId, ticketType });
            return null;
        }

        const response = await axios.patch(url, payload, {
            auth: apiConfig.servicenowAuthentication.auth
        });

        // Verificar se retorna status 200 para sucesso
        if (response.status !== 200) {
            logError(`❌ Falha ao criar comentário. Status: ${response.status}`, { sysId, ticketType });
            return null;
        }

        // retornar id do comentário criado
        const commentId = await getCommentId(sysId, comment);

        if (!commentId) {
            logError('❌ Comentário criado, mas não foi possível obter o ID do comentário', { sysId });
            return null;
        }

        logInfo(`✅ Comentário criado com sucesso no ServiceNow. Comment ID: ${commentId}`, { sysId, ticketType });

        return commentId;

    } catch (error) {
        logError(error, '🚨Falha ao criar comentário no ServiceNow');
    }
}

const syncCommentToServiceNow = async (ticketId, comment) => {
    logInfo(`Iniciando sincronização do comentário para o ticket SN Ticket: ${ticketId}`);
    const snSysId = await getTicketSysId(ticketId);
    const ticketType = await getTicketTypeById(ticketId);

    if (!snSysId) {
        logError(`❌ sys_id do ServiceNow não encontrado para o ticket SN Ticket: ${ticketId}`);
        return null;
    }
    const snCommentId = await createCommentInServiceNow(snSysId, comment, ticketType);
    return snCommentId;
}

// Função que verifica se o comentário já existe no ServiceNow antes de criar
    const existingCommentInServiceNow = async (ticketId, comment) => {
    try {
        const sys_id = await getTicketSysId(ticketId);
        const commentExists = await getCommentId(sys_id, comment);
        return commentExists;

    } catch (error) {
        logError(error, '🚨Falha ao verificar existência do comentário no ServiceNow');
        return false;
    }
}

module.exports = {
    fetchTicketsFromServiceNow,
    fetchRequestsFromServiceNow,
    getTicketSysId,
    createCommentInServiceNow,
    getCommentId,
    existingCommentInServiceNow,
    syncCommentToServiceNow
}