//src/modules/tickes/useCases/syncTickets.usecase.js

const notifyTicketCreated = require('../services/ticketNotifications.service.js')
const repository = require ('../repositories/ticket.repository.js') 
const mundialeService = require('../services/mundiale.service.js')
const implantacaoService = require('../services/implantacao.service.js')
const cancelamentoService = require('../services/cancelamento.service.js')
//const sacService = require('../services/sac.service.js') //TODO
const trocaTitularidadeService = require('../services/trocaTitularidade.service.js') //TODO

const getAuthToken = require('../../../infra/api/hubsoft.auth.js')


const ticketShared = require('../services/createTickets.service.js')
const { logInfo, logError } = require('../../../shared/utils/logger.js')

async function syncTicketsUseCase() {


  logInfo('[USECASE] Buscando novos tickets no Hubsoft')

  const waterMark = await repository.getWaterMark()
  logInfo(`Buscando Tickets novos desde de: ${waterMark}`)

  const mundiale =  await mundialeService.fetchNew(waterMark)
  logInfo(`[USECASE] ${mundiale.length} tickets Mundiale encontrados`)

  const implantacao = await implantacaoService.fetchNew(waterMark)
  logInfo(`[USECASE] ${implantacao.length} tickets Implantação encontrados`)

  const cancelamento = await cancelamentoService.fetchNew(waterMark)
  logInfo(`[USECASE] ${cancelamento.length} tickets Cancelamento encontrados`)

  //const sac = await sacService.fetchNew(waterMark) //TODO
  //logInfo(`[USECASE] ${sac.length} tickets SAC encontrados`) 
  
  const trocaTitularidade = await trocaTitularidadeService.fetchNew(waterMark) //TODO
  logInfo(`[USECASE] ${trocaTitularidade.length} tickets Troca de Titularidade encontrados`)
  

  //await mundialeService.saveHubGlpi(mundiale)
  //await implantacaoService.saveHubGlpi(implantacao)
  //await cancelamentoService.saveHubGlpi(cancelamento)
  //await sacService.saveHubGlpi(sac) //TODO
  await trocaTitularidadeService.saveHubGlpi(trocaTitularidade) //TODO

  const allFetchedTickets = [
    ...mundiale,
    ...implantacao,
    ...cancelamento,
    //...sac,
    ...trocaTitularidade
  ]

  const newWaterMark = resolveNewWatermark(allFetchedTickets, waterMark)

  if (newWaterMark !== waterMark) {
    await repository.updateWaterMark(newWaterMark)
    logInfo(`[USECASE] Watermark atualizada para: ${newWaterMark}`)
  }

  const pendentes = await ticketShared.fetchPendingTickets()
  logInfo(`[USECASE] ${pendentes.length} tickets pendentes para envio ao GLPI`)

  for (const ticket of pendentes) {
  try {
    const service = resolveTicketService(ticket.ticket_type)
    if (!service) continue

    const glpiId = await service.sendToGlpi(ticket)
    await notifyTicketCreated.notifyTicketCreated(ticket.id_atendimento, glpiId)
  } catch (err) {
    logError(err, `[USECASE] Falha ao processar ticket ${ticket.id_atendimento}`)
  }
}

}


function resolveTicketService(type) {
  const map = {
    MUNDIALE: mundialeService,
    IMPLANTACAO: implantacaoService,
    CANCELAMENTO: cancelamentoService,
    //SAC: sacService, //TODO
    TITULARIDADE: trocaTitularidadeService //TODO
  }

  return map[type]
}
function resolveNewWatermark(tickets, currentWatermark) {
  if (!tickets?.length) return currentWatermark

  return tickets.reduce((max, ticket) => {
    if (!ticket.created_at) return max
    return ticket.created_at > max ? ticket.created_at : max
  }, currentWatermark)
}



module.exports = { syncTicketsUseCase }