// src/models/glpiModel.js
const dbConfig = require('../config/dbConfig.js');
const { logError, logInfo} = require('../utils/logger');
const mysql = require('mysql2/promise');

const pool = mysql.createPool({
    host: dbConfig.glpi.databaseHost,
    port: dbConfig.glpi.databasePort,
    database: dbConfig.glpi.databaseName,
    user: dbConfig.glpi.databaseUser,
    password: dbConfig.glpi.databasePassword,
    waitForConnections: true,
    connectionLimit: 10,
    queueLimit: 0
});


class GlpiModel {

    static async insertTicket(ticketData) {
        
        const query = `
            INSERT INTO glpi_tickets(
                entities_id,
                name,
                date,
                date_mod,
                status,
                users_id_recipient,
                content,
                urgency,
                impact,
                priority,
                type,
                itilcategories_id,
                date_creation,
                slas_id_ttr
                )
                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
            `;

        const values = [
            ticketData.entidades_id,
            ticketData.titulo,
            ticketData.created_at,
            ticketData.date_mod,
            ticketData.status_atendimento,
            ticketData.user_id_recipient,
            ticketData.descricao_abertura,
            ticketData.urgency,
            ticketData.impact,
            ticketData.priority,
            2,
            ticketData.itilcategories_id,
            ticketData.date_creation,
            37
        ];
        try {
            const [rows] = await pool.execute(query, values)
            return rows;
        } catch (error) {
            logError('Erro ao inserir ticket:', error);
            throw error;
        }
    }

    static async selectEntityIdCodCliente(id) {

        const query = `SELECT id FROM glpi_entities WHERE name LIKE ? OR name LIKE ? LIMIT 1;`;
        const values = [`${id} -%`, `${id}-%`];

        try {
            const [rows] = await pool.execute(query, values);
            if (!rows || rows.length === 0) {
                logInfo(`Entidade não encontrada por código de cliente para: ${id} `);
                return null;
            }

            logInfo(`Entidade encontrada por código de cliente para: ${id}`);


            return Number(rows[0].id);
        } catch (err) {
            logError(`Erro ao buscar entidade por código de cliente: ${err}`);
            throw err;
        }
    }

    static async selectEntityIdCodServico(idCliente, idServico) {

        const query = `SELECT id FROM glpi_entities WHERE name LIKE ? LIMIT 1;`;
        const values = [`${idCliente} - ${idServico} %`];

        try {
            const [rows] = await pool.execute(query, values);
            if (!rows || rows.length === 0) {
                logInfo(`Entidade não encontrada por código de serviço para: ${idServico} `);
                return null;
            }

            logInfo(`Entidade encontrada por código de serviço para: ${idServico}`);


            return Number(rows[0].id);
        } catch (err) {
            logError(`Erro ao buscar entidade por código de serviço: ${err}`);
            throw err;
        }
    }

    static async insertGroupTickets(glpiTicketId) {
            const query = `
                INSERT INTO glpi_groups_tickets (tickets_id, groups_id, type)
                VALUES (?, ?, ?)
                `;
            const values = [glpiTicketId, 25, 2];
            try {
                const [rows] = await pool.query(query, values);
                return rows && rows.insertId ? rows.insertId : null;
            }
            catch (err) {   
                logError(`Erro ao Adicionar Grupo Operação NOC: ${err}`);
                throw err;
            }
        }

}

module.exports = GlpiModel;