/**
 * simulateUsage.js
 *
 * Gera dois arquivos SQL:
 *   logs/simulation-seed.sql     → insere dados de simulação
 *   logs/simulation-cleanup.sql  → remove os dados inseridos
 *
 * e um relatório legível:
 *   logs/simulation-report.txt
 *   logs/simulation-log.txt
 *
 * COMO USAR:
 *   1. Preencha scripts/simulation/simulation.config.js com seu OWNER_ID e TENANT_ID
 *   2. npm run simulate
 *   3. Abra o Supabase SQL Editor e rode simulation-seed.sql
 *   4. Teste o sistema
 *   5. Quando terminar, rode simulation-cleanup.sql para limpar
 */

import fs from 'fs'
import path from 'path'
import { config } from './simulation.config.js'
import { logInfo, logWarning, logError, getLog } from './simulationLogger.js'

// ─── Validação ────────────────────────────────────────────────────────────────

if (config.OWNER_ID === 'SEU-OWNER-UUID-AQUI' || config.TENANT_ID === 'SEU-TENANT-UUID-AQUI') {
  console.error('\n❌ ERRO: Preencha OWNER_ID e TENANT_ID em scripts/simulation/simulation.config.js\n')
  process.exit(1)
}

// ─── Dados brasileiros falsos ─────────────────────────────────────────────────

const NOMES = [
  ['Ana', 'Beatriz', 'Carla', 'Daniela', 'Fernanda', 'Gabriela', 'Helena', 'Isabela',
   'Juliana', 'Karen', 'Laura', 'Mariana', 'Natália', 'Olivia', 'Patrícia'],
  ['Carlos', 'Daniel', 'Eduardo', 'Felipe', 'Gustavo', 'Henrique', 'Igor', 'João',
   'Lucas', 'Marcos', 'Nelson', 'Otávio', 'Paulo', 'Rafael', 'Sérgio'],
]

const SOBRENOMES = [
  'Silva', 'Santos', 'Oliveira', 'Souza', 'Lima', 'Ferreira', 'Rodrigues',
  'Almeida', 'Costa', 'Gomes', 'Martins', 'Pereira', 'Carvalho', 'Rocha', 'Nunes',
]

const MODALIDADES = ['presencial', 'online', 'presencial', 'presencial'] // ponderado

// ─── Utilitários ─────────────────────────────────────────────────────────────

let _rng = 1

function rng () {
  // LCG determinístico para gerar sequência reproduzível
  _rng = (_rng * 1664525 + 1013904223) & 0xffffffff
  return Math.abs(_rng) / 0x80000000
}

function pick (arr) { return arr[Math.floor(rng() * arr.length)] }

function uuid () {
  // gera UUID v4-like determinístico baseado no nosso rng
  const h = () => Math.floor(rng() * 0x10000).toString(16).padStart(4, '0')
  return `${h()}${h()}-${h()}-4${h().slice(1)}-${(8 + Math.floor(rng() * 4)).toString(16)}${h().slice(1)}-${h()}${h()}${h()}`
}

function addDays (date, n) {
  const d = new Date(date)
  d.setDate(d.getDate() + n)
  return d
}

function toISO (date) {
  return date.toISOString().split('T')[0]
}

function toISODateTime (date, hh, mm) {
  return `${toISO(date)}T${String(hh).padStart(2,'0')}:${String(mm).padStart(2,'0')}:00`
}

function sqlStr (v) {
  if (v === null || v === undefined) return 'NULL'
  return `'${String(v).replace(/'/g, "''")}'`
}

function weekdayName (n) {
  return ['Dom','Seg','Ter','Qua','Qui','Sex','Sáb'][n]
}

// ─── Gerador de nomes únicos ──────────────────────────────────────────────────

const usedNames = new Set()

function fakeName () {
  let attempts = 0
  while (attempts < 50) {
    const gender = rng() > 0.5 ? 0 : 1
    const nome = pick(NOMES[gender])
    const sobrenome = pick(SOBRENOMES)
    const full = `${nome} ${sobrenome}`
    if (!usedNames.has(full)) {
      usedNames.add(full)
      return full
    }
    attempts++
  }
  return `Paciente ${usedNames.size + 1}`
}

function fakeCpf () {
  const n = () => Math.floor(rng() * 9) + 1
  return `${n()}${n()}${n()}${n()}${n()}${n()}${n()}${n()}${n()}${n()}${n()}`
}

function fakePhone () {
  const ddd = [11,21,31,41,51,61,71,81,91][Math.floor(rng() * 9)]
  const num = Math.floor(rng() * 900000000) + 900000000
  return `(${ddd}) 9${String(num).slice(1,5)}-${String(num).slice(5,9)}`
}

function fakeEmail (nome) {
  const slug = nome.toLowerCase()
    .replace(/\s+/g, '.')
    .normalize('NFD').replace(/[\u0300-\u036f]/g, '')
  const num = Math.floor(rng() * 99) + 1
  const domains = ['gmail.com','hotmail.com','outlook.com','yahoo.com.br']
  return `${slug}${num}@${pick(domains)}`
}

// ─── Blocos SQL ───────────────────────────────────────────────────────────────

const seedLines = []
const cleanupIds = {
  patients: [],
  agendaEventos: [],
  recurrenceRules: [],
  recurrenceExceptions: [],
  agendadorSolicitacoes: [],
  agendaConfiguracoes: [],
  agendaRegrasSemanais: [],
}

function emit (line) { seedLines.push(line) }

// ─── Construção da simulação ──────────────────────────────────────────────────

const TODAY      = new Date()
TODAY.setHours(0, 0, 0, 0)
const PAST_START  = addDays(TODAY, -config.DAYS_BACK)
const FUTURE_END  = addDays(TODAY, config.SIMULATION_DAYS)

const ownerId  = config.OWNER_ID
const tenantId = config.TENANT_ID

logInfo('Iniciando simulação...')
logInfo(`OWNER_ID:  ${ownerId}`)
logInfo(`TENANT_ID: ${tenantId}`)
logInfo(`Período:   ${toISO(PAST_START)} → ${toISO(FUTURE_END)}`)

// ─── 1. Pacientes ─────────────────────────────────────────────────────────────

emit('-- ============================================================')
emit('-- SIMULAÇÃO AgenciaPsi — gerado por npm run simulate')
emit(`-- Data: ${new Date().toLocaleString('pt-BR')}`)
emit('-- ============================================================')
emit('')
emit('-- Desabilita triggers para permitir inserts de simulação')
emit('SET session_replication_role = replica;')
emit('')
emit('BEGIN;')
emit('')
emit('-- ─── 1. Pacientes ───────────────────────────────────────────────────────────')
emit('')

const patients = []

for (let i = 0; i < config.PATIENTS_COUNT; i++) {
  const id    = uuid()
  const nome  = fakeName()
  const parts = nome.split(' ')
  const email = fakeEmail(nome)
  const tel   = fakePhone()
  const cpf   = fakeCpf()

  patients.push({ id, nome_completo: nome, email, telefone: tel })
  cleanupIds.patients.push(id)

  emit(`INSERT INTO patients (id, tenant_id, owner_id, responsible_member_id, nome_completo, email_principal, telefone, cpf, patient_scope, status)`)
  emit(`  VALUES (${sqlStr(id)}, ${sqlStr(tenantId)}, ${sqlStr(ownerId)},`)
  emit(`    (SELECT id FROM tenant_members WHERE user_id = ${sqlStr(ownerId)} AND tenant_id = ${sqlStr(tenantId)} LIMIT 1),`)
  emit(`    ${sqlStr(nome)}, ${sqlStr(email)}, ${sqlStr(tel)}, ${sqlStr(cpf)}, 'clinic', 'Ativo');`)
}

logInfo(`✔ ${patients.length} pacientes criados`)
emit('')

// ─── 2. Configurações de agenda ───────────────────────────────────────────────

emit('-- ─── 2. Configurações de agenda ─────────────────────────────────────────────')
emit('')

const pausas = [
  { weekday: 1, start: '12:00', end: '13:00', label: 'Almoço' },
  { weekday: 2, start: '12:00', end: '13:00', label: 'Almoço' },
  { weekday: 3, start: '12:00', end: '13:00', label: 'Almoço' },
  { weekday: 4, start: '12:00', end: '13:00', label: 'Almoço' },
  { weekday: 5, start: '12:00', end: '13:00', label: 'Almoço' },
]

emit(`INSERT INTO agenda_configuracoes (owner_id, tenant_id, session_duration_min, session_break_min, pausas_semanais, online_ativo, setup_clinica_concluido)`)
emit(`  VALUES (${sqlStr(ownerId)}, ${sqlStr(tenantId)},`)
emit(`    ${config.SESSION_DURATION_MIN}, 10, '${JSON.stringify(pausas)}'::jsonb, true, true)`)
emit(`  ON CONFLICT (owner_id) DO NOTHING;`)
emit('')

logInfo('✔ agenda_configuracoes inserida')

// ─── 3. Regras semanais de disponibilidade ────────────────────────────────────

emit('-- ─── 3. Regras semanais ─────────────────────────────────────────────────────')
emit('')

const workDays = [1, 2, 3, 4, 5] // seg–sex
for (const dia of workDays) {
  const rid = uuid()
  cleanupIds.agendaRegrasSemanais.push(rid)
  emit(`INSERT INTO agenda_regras_semanais (id, owner_id, tenant_id, dia_semana, hora_inicio, hora_fim, ativo)`)
  emit(`  VALUES (${sqlStr(rid)}, ${sqlStr(ownerId)}, ${sqlStr(tenantId)}, ${dia}, '08:00', '18:00', true);`)
}

logInfo(`✔ ${workDays.length} regras semanais inseridas`)
emit('')

// ─── 4. Eventos avulsos (passado) ─────────────────────────────────────────────

emit('-- ─── 4. Eventos avulsos (passado) ──────────────────────────────────────────')
emit('')

const avulsoCount = 3
const avulsoPatients = patients.slice(0, avulsoCount)
let avulsosCreated = 0

// Avulsos usam 13h para não conflitar com séries (9h–12h e 14h–17h)
for (const pat of avulsoPatients) {
  const daysAgo = Math.floor(rng() * config.DAYS_BACK) + 1
  const date    = addDays(TODAY, -daysAgo)
  if (date.getDay() === 0 || date.getDay() === 6) continue // pular fds

  const hour    = 13
  const startDT = toISODateTime(date, hour, 0)
  const endDT   = toISODateTime(date, hour, 50)
  const evId    = uuid()
  const modal   = pick(MODALIDADES)
  const statuses = ['realizado', 'faltou', 'agendado']
  const status  = pick(statuses)

  cleanupIds.agendaEventos.push(evId)

  emit(`INSERT INTO agenda_eventos (id, owner_id, tenant_id, patient_id, tipo, status, inicio_em, fim_em, modalidade, titulo)`)
  emit(`  VALUES (${sqlStr(evId)}, ${sqlStr(ownerId)}, ${sqlStr(tenantId)}, ${sqlStr(pat.id)},`)
  emit(`    'sessao', ${sqlStr(status)}, ${sqlStr(startDT)}, ${sqlStr(endDT)}, ${sqlStr(modal)}, 'Sessão avulsa');`)

  avulsosCreated++
}

logInfo(`✔ ${avulsosCreated} eventos avulsos criados`)
emit('')

// ─── 5. Séries de recorrência ─────────────────────────────────────────────────

emit('-- ─── 5. Séries de recorrência ───────────────────────────────────────────────')
emit('')

const ruleStartDate = addDays(TODAY, -config.DAYS_BACK)
const ruleEndDate   = addDays(TODAY, config.SIMULATION_DAYS)

// Distribui pacientes pelas séries (cicla se menos pacientes que séries)
const seriesPatients = patients.slice(0, config.RECURRENCE_RULES_COUNT)
const types     = ['weekly', 'weekly', 'weekly', 'biweekly', 'custom_weekdays', 'weekly']
const wdays     = [[1], [2], [4], [1], [1,3], [3]]
// Cada série tem seu próprio horário para evitar sobreposição
const ruleHours = [9, 10, 11, 14, 15, 16]

const recurrenceRules = []

for (let i = 0; i < config.RECURRENCE_RULES_COUNT; i++) {
  const pat      = seriesPatients[i % seriesPatients.length]
  const type     = types[i] || 'weekly'
  const weekdays = wdays[i] || [1]
  const modal    = pick(MODALIDADES)
  const ruleId   = uuid()
  const hour     = ruleHours[i] || (9 + i)
  const startTime = `${String(hour).padStart(2,'0')}:00`
  const endTime   = `${String(hour).padStart(2,'0')}:50`
  const weekdaysArr = `ARRAY[${weekdays.join(',')}]::smallint[]`

  recurrenceRules.push({ id: ruleId, patient: pat, type, weekdays, start_date: ruleStartDate, modal, hour })
  cleanupIds.recurrenceRules.push(ruleId)

  emit(`INSERT INTO recurrence_rules (id, owner_id, tenant_id, patient_id, type, weekdays, interval, start_date, end_date, status, start_time, end_time, modalidade)`)
  emit(`  VALUES (${sqlStr(ruleId)}, ${sqlStr(ownerId)}, ${sqlStr(tenantId)}, ${sqlStr(pat.id)},`)
  emit(`    ${sqlStr(type)}, ${weekdaysArr}, 1, ${sqlStr(toISO(ruleStartDate))}, ${sqlStr(toISO(ruleEndDate))},`)
  emit(`    'ativo', ${sqlStr(startTime)}, ${sqlStr(endTime)}, ${sqlStr(modal)});`)
}

logInfo(`✔ ${recurrenceRules.length} regras de recorrência criadas`)
emit('')

// ─── 6. Exceções de recorrência (passado) ────────────────────────────────────

emit('-- ─── 6. Exceções de recorrência ────────────────────────────────────────────')
emit('')

let excFaltou = 0, excRemarcado = 0, excCancelado = 0

for (const rr of recurrenceRules) {
  // Gera datas das ocorrências passadas
  const occs = []
  let cur = new Date(rr.start_date)
  // avançar para o primeiro dia correto
  while (cur <= TODAY) {
    const dow = cur.getDay()
    if (rr.weekdays.includes(dow)) {
      if (cur < TODAY) occs.push(new Date(cur))
    }
    cur = addDays(cur, 1)
  }

  for (const occDate of occs) {
    const r = rng()
    const dateStr = toISO(occDate)

    if (r < config.RATE_FALTOU) {
      const excId = uuid()
      cleanupIds.recurrenceExceptions.push(excId)
      emit(`INSERT INTO recurrence_exceptions (id, recurrence_id, tenant_id, original_date, type, new_date)`)
      emit(`  VALUES (${sqlStr(excId)}, ${sqlStr(rr.id)}, ${sqlStr(tenantId)}, ${sqlStr(dateStr)}, 'patient_missed', NULL);`)
      excFaltou++
    } else if (r < config.RATE_FALTOU + config.RATE_REMARCADO) {
      const offset   = Math.floor(rng() * 4) + 1
      const newDate  = addDays(occDate, offset)
      // não remarcar para fds
      if (newDate.getDay() === 0 || newDate.getDay() === 6) continue
      const excId = uuid()
      cleanupIds.recurrenceExceptions.push(excId)
      emit(`INSERT INTO recurrence_exceptions (id, recurrence_id, tenant_id, original_date, type, new_date)`)
      emit(`  VALUES (${sqlStr(excId)}, ${sqlStr(rr.id)}, ${sqlStr(tenantId)}, ${sqlStr(dateStr)}, 'reschedule_session', ${sqlStr(toISO(newDate))});`)
      excRemarcado++
    } else if (r < config.RATE_FALTOU + config.RATE_REMARCADO + config.RATE_CANCELADO) {
      const excId = uuid()
      cleanupIds.recurrenceExceptions.push(excId)
      emit(`INSERT INTO recurrence_exceptions (id, recurrence_id, tenant_id, original_date, type, new_date)`)
      emit(`  VALUES (${sqlStr(excId)}, ${sqlStr(rr.id)}, ${sqlStr(tenantId)}, ${sqlStr(dateStr)}, 'cancel_session', NULL);`)
      excCancelado++
    }
  }
}

logInfo(`✔ Exceções: ${excFaltou} faltou, ${excRemarcado} remarcado, ${excCancelado} cancelado`)
emit('')

// ─── 7. Sessões reais para ocorrências passadas (realizado/faltou) ────────────

emit('-- ─── 7. Sessões reais (passado — realizado/faltou) ────────────────────────')
emit('')

let realSessionsCreated = 0

for (const rr of recurrenceRules) {
  let cur2 = new Date(rr.start_date)
  while (cur2 < TODAY) {
    const dow = cur2.getDay()
    if (rr.weekdays.includes(dow)) {
      const dateStr  = toISO(cur2)
      const evId     = uuid()
      const hh       = String(rr.hour).padStart(2, '0')
      const startDT  = `${dateStr}T${hh}:00:00`
      const endDT    = `${dateStr}T${hh}:50:00`
      // status baseado nas exceções: se há exceção faltou → faltou, else → realizado
      // simplificado: 80% realizado, 20% faltou para sessões passadas
      const status = rng() < 0.8 ? 'realizado' : 'faltou'

      cleanupIds.agendaEventos.push(evId)

      emit(`INSERT INTO agenda_eventos (id, owner_id, tenant_id, patient_id, tipo, status, inicio_em, fim_em, modalidade, recurrence_id, recurrence_date)`)
      emit(`  VALUES (${sqlStr(evId)}, ${sqlStr(ownerId)}, ${sqlStr(tenantId)}, ${sqlStr(rr.patient.id)},`)
      emit(`    'sessao', ${sqlStr(status)}, ${sqlStr(startDT)}, ${sqlStr(endDT)}, ${sqlStr(rr.modal)}, ${sqlStr(rr.id)}, ${sqlStr(dateStr)});`)

      realSessionsCreated++
    }
    cur2 = addDays(cur2, 1)
  }
}

logInfo(`✔ ${realSessionsCreated} sessões reais (passado) criadas`)
emit('')

// ─── 8. Solicitações do Agendador Público ─────────────────────────────────────

emit('-- ─── 8. Agendador Público — solicitações pendentes ─────────────────────────')
emit('')

const agendadorStatuses = ['pendente', 'pendente', 'pendente', 'autorizado', 'recusado']

for (let i = 0; i < config.AGENDADOR_REQUESTS_COUNT; i++) {
  const nome      = fakeName()
  const parts2    = nome.split(' ')
  const primeiro  = parts2[0]
  const sobrenome = parts2.slice(1).join(' ')
  const email     = fakeEmail(nome)
  const cel       = fakePhone()
  const daysAhead = Math.floor(rng() * 14) + 1
  const reqDate   = addDays(TODAY, daysAhead)
  if (reqDate.getDay() === 0 || reqDate.getDay() === 6) continue
  const hour    = config.WORK_HOUR_START + Math.floor(rng() * 6)
  const hora    = `${String(hour).padStart(2,'0')}:00`
  const modal   = pick(MODALIDADES)
  const status  = pick(agendadorStatuses)
  const solId   = uuid()

  cleanupIds.agendadorSolicitacoes.push(solId)

  emit(`INSERT INTO agendador_solicitacoes (id, owner_id, tenant_id, paciente_nome, paciente_sobrenome, paciente_email, paciente_celular, tipo, modalidade, data_solicitada, hora_solicitada, status)`)
  emit(`  VALUES (${sqlStr(solId)}, ${sqlStr(ownerId)}, ${sqlStr(tenantId)}, ${sqlStr(primeiro)}, ${sqlStr(sobrenome)}, ${sqlStr(email)}, ${sqlStr(cel)},`)
  emit(`    ${sqlStr(pick(['primeira', 'retorno', 'reagendar']))}, ${sqlStr(modal)}, ${sqlStr(toISO(reqDate))}, ${sqlStr(hora)}, ${sqlStr(status)});`)
}

logInfo(`✔ ${config.AGENDADOR_REQUESTS_COUNT} solicitações do agendador criadas`)
emit('')

// ─── 9. Fechar transação ──────────────────────────────────────────────────────

emit('COMMIT;')
emit('')
emit('-- Restaura comportamento normal dos triggers')
emit('SET session_replication_role = DEFAULT;')
emit('')
emit('-- ─── Fim do seed ────────────────────────────────────────────────────────────')

// ─── Gerar SQL de cleanup ────────────────────────────────────────────────────

function buildCleanupSQL () {
  const lines = []
  lines.push('-- ============================================================')
  lines.push('-- CLEANUP — remove dados da simulação AgenciaPsi')
  lines.push(`-- Data: ${new Date().toLocaleString('pt-BR')}`)
  lines.push('-- ============================================================')
  lines.push('')
  lines.push('SET session_replication_role = replica;')
  lines.push('')
  lines.push('BEGIN;')
  lines.push('')

  function delBlock (table, ids) {
    if (ids.length === 0) return
    const quoted = ids.map(id => `'${id}'`).join(', ')
    lines.push(`DELETE FROM ${table} WHERE id IN (${quoted});`)
  }

  delBlock('recurrence_exceptions', cleanupIds.recurrenceExceptions)
  lines.push('')
  delBlock('agenda_eventos', cleanupIds.agendaEventos)
  lines.push('')
  delBlock('recurrence_rules', cleanupIds.recurrenceRules)
  lines.push('')
  delBlock('agendador_solicitacoes', cleanupIds.agendadorSolicitacoes)
  lines.push('')
  delBlock('agenda_regras_semanais', cleanupIds.agendaRegrasSemanais)
  lines.push('')
  // agenda_configuracoes: PK é owner_id, não id
  lines.push(`-- Descomente se quiser remover também as configurações de agenda:`)
  lines.push(`-- DELETE FROM agenda_configuracoes WHERE owner_id = ${sqlStr(ownerId)};`)
  lines.push('')
  delBlock('patients', cleanupIds.patients)
  lines.push('')
  lines.push('COMMIT;')
  lines.push('')
  lines.push('SET session_replication_role = DEFAULT;')
  lines.push('')
  lines.push('-- ─── Fim do cleanup ─────────────────────────────────────────────────────────')

  return lines.join('\n')
}

// ─── Relatório ────────────────────────────────────────────────────────────────

function buildReport () {
  const lines = []
  lines.push('============================================================')
  lines.push('  RELATÓRIO DE SIMULAÇÃO — AgenciaPsi')
  lines.push(`  Gerado em: ${new Date().toLocaleString('pt-BR')}`)
  lines.push('============================================================')
  lines.push('')
  lines.push(`OWNER_ID:  ${ownerId}`)
  lines.push(`TENANT_ID: ${tenantId}`)
  lines.push('')
  lines.push('─── Dados gerados ─────────────────────────────────────────')
  lines.push(`  Pacientes:                ${patients.length}`)
  lines.push(`  Séries de recorrência:    ${recurrenceRules.length}`)
  lines.push(`  Sessões reais (passado):  ${realSessionsCreated}`)
  lines.push(`  Eventos avulsos:          ${avulsosCreated}`)
  lines.push(`  Exceções — faltou:        ${excFaltou}`)
  lines.push(`  Exceções — remarcado:     ${excRemarcado}`)
  lines.push(`  Exceções — cancelado:     ${excCancelado}`)
  lines.push(`  Solicitações agendador:   ${config.AGENDADOR_REQUESTS_COUNT}`)
  lines.push('')
  lines.push('─── Pacientes criados ─────────────────────────────────────')
  for (const p of patients) {
    lines.push(`  [${p.id}] ${p.nome_completo} — ${p.email}`)
  }
  lines.push('')
  lines.push('─── Séries de recorrência ─────────────────────────────────')
  for (const r of recurrenceRules) {
    const dias = r.weekdays.map(d => weekdayName(d)).join(', ')
    lines.push(`  [${r.id}]`)
    lines.push(`    Paciente: ${r.patient.nome_completo}`)
    lines.push(`    Tipo: ${r.type}  |  Dias: ${dias}`)
    lines.push(`    Período: ${toISO(r.start_date)} → ${toISO(FUTURE_END)}`)
  }
  lines.push('')
  lines.push('─── Como testar ───────────────────────────────────────────')
  lines.push('  1. Abra o Supabase SQL Editor')
  lines.push('  2. Cole e rode: logs/simulation-seed.sql')
  lines.push('  3. Acesse a agenda — os eventos devem aparecer')
  lines.push('  4. Acesse Pacientes — pacientes simulados aparecem na lista')
  lines.push('  5. Acesse Agendamentos Recebidos — solicitações pendentes')
  lines.push('  6. Quando terminar, rode: logs/simulation-cleanup.sql')
  lines.push('')
  lines.push('============================================================')

  return lines.join('\n')
}

// ─── Salvar arquivos ─────────────────────────────────────────────────────────

const outDir = path.resolve(config.OUTPUT_DIR)
if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true })

const seedPath    = path.join(outDir, 'simulation-seed.sql')
const cleanupPath = path.join(outDir, 'simulation-cleanup.sql')
const reportPath  = path.join(outDir, 'simulation-report.txt')
const logPath     = path.join(outDir, 'simulation-log.txt')

fs.writeFileSync(seedPath,    seedLines.join('\n'), 'utf-8')
fs.writeFileSync(cleanupPath, buildCleanupSQL(),    'utf-8')
fs.writeFileSync(reportPath,  buildReport(),        'utf-8')

logInfo(`✔ Seed SQL:    ${seedPath}`)
logInfo(`✔ Cleanup SQL: ${cleanupPath}`)
logInfo(`✔ Relatório:   ${reportPath}`)

fs.writeFileSync(logPath, getLog(), 'utf-8')

console.log('\n✅ Simulação concluída. Arquivos em logs/')
console.log('   → Rode simulation-seed.sql no Supabase SQL Editor para inserir os dados')
console.log('   → Rode simulation-cleanup.sql quando quiser remover\n')