/**
 * WhatsApp Warmer — aquecimento gradual de número novo.
 *
 * Envia mensagens em intervalos aleatórios crescentes para simular
 * uso humano e reduzir risco de ban em números recém-criados.
 */
import { logger } from '../../../config/logger'
import type { WhatsAppConnectionManager } from '../connection/WhatsAppConnectionManager'

interface WarmerConfig {
  instanceId: string
  targets: string[]         // JIDs destino (ex: contatos da agenda)
  totalDays: number         // Duração do aquecimento (ex: 7 dias)
  dailyMessageLimit: number // Máximo de msgs por dia (cresce gradualmente)
}

interface WarmerSession {
  config: WarmerConfig
  dayCount: number
  sentToday: number
  timer: ReturnType<typeof setTimeout> | null
}

const MESSAGES = [
  'Olá! Tudo bem?',
  'Oi, como vai?',
  'Boa tarde!',
  'Só passando para dizer oi 😊',
  'Tudo certo por aí?',
  'Bom dia! 🌤',
  'E aí, tudo bem?',
  'Boa noite!',
]

function randomBetween(min: number, max: number): number {
  return Math.floor(Math.random() * (max - min + 1)) + min
}

function randomMessage(): string {
  return MESSAGES[Math.floor(Math.random() * MESSAGES.length)]
}

export class WhatsAppWarmer {
  private sessions = new Map<string, WarmerSession>()

  constructor(private manager: WhatsAppConnectionManager) {}

  start(config: WarmerConfig): void {
    if (this.sessions.has(config.instanceId)) {
      logger.warn({ instanceId: config.instanceId }, 'Warmer já em execução para esta instância')
      return
    }

    const session: WarmerSession = {
      config,
      dayCount: 0,
      sentToday: 0,
      timer: null,
    }

    this.sessions.set(config.instanceId, session)
    logger.info({ instanceId: config.instanceId, totalDays: config.totalDays }, '🔥 Warmer iniciado')
    this.scheduleNext(config.instanceId)
  }

  stop(instanceId: string): void {
    const session = this.sessions.get(instanceId)
    if (!session) return
    if (session.timer) clearTimeout(session.timer)
    this.sessions.delete(instanceId)
    logger.info({ instanceId }, 'Warmer encerrado')
  }

  private scheduleNext(instanceId: string): void {
    const session = this.sessions.get(instanceId)
    if (!session) return

    const { config, dayCount, sentToday } = session

    // Limite diário cresce linearmente: day 1 = 10%, day N = 100%
    const progressRatio = Math.min(1, (dayCount + 1) / config.totalDays)
    const limitHoje = Math.ceil(config.dailyMessageLimit * progressRatio)

    if (sentToday >= limitHoje) {
      // Dia completo — aguarda até o próximo dia (24h + jitter)
      const nextDayMs = 24 * 60 * 60 * 1000 + randomBetween(0, 30 * 60 * 1000)
      logger.debug({ instanceId, dayCount, sentToday }, 'Limite diário atingido — aguardando próximo dia')

      if (dayCount + 1 >= config.totalDays) {
        logger.info({ instanceId }, '✅ Aquecimento concluído!')
        this.sessions.delete(instanceId)
        return
      }

      session.dayCount += 1
      session.sentToday = 0
      session.timer = setTimeout(() => this.scheduleNext(instanceId), nextDayMs)
      return
    }

    // Intervalo aleatório entre mensagens (1–5 minutos com jitter)
    const delayMs = randomBetween(60_000, 5 * 60_000)
    session.timer = setTimeout(() => this.sendWarmerMessage(instanceId), delayMs)
  }

  private async sendWarmerMessage(instanceId: string): Promise<void> {
    const session = this.sessions.get(instanceId)
    if (!session) return

    const sock = this.manager.getSocket(instanceId)
    if (!sock) {
      logger.warn({ instanceId }, 'Warmer: socket não encontrado — pausando')
      session.timer = setTimeout(() => this.sendWarmerMessage(instanceId), 60_000)
      return
    }

    const targets = session.config.targets
    const target = targets[Math.floor(Math.random() * targets.length)]
    const text = randomMessage()

    try {
      await sock.sendMessage(target, { text })
      session.sentToday += 1
      logger.debug({ instanceId, target, sentToday: session.sentToday }, 'Warmer: mensagem enviada')
    } catch (err) {
      logger.error({ err, instanceId, target }, 'Warmer: falha ao enviar mensagem')
    }

    this.scheduleNext(instanceId)
  }
}
