/**
 * Sincroniza la columna status "Etapa" del tablero Unidades (pipeline de 10
 * etapas: Apartado → Reserva → Vendido → Integración → En Análisis → Autorizado
 * → Notaría → Escriturado → Entrega → PostVenta) desde un JSON de etapas.
 *
 * Formatos de entrada aceptados:
 *   - Simple:   [{ "codigo": "ATELIER-1", "etapa": "NOTARIA" }, ...]
 *   - Maestro:  reference/maestro/maestro-unidades.json (codigo_nuestro +
 *               etapa_maestro + mapeo.confianza; solo se usan confianza
 *               alta/media). Es el default.
 *
 * Idempotente: solo escribe en Monday si la etapa cambió.
 *
 * Traspasos de departamento (dedup en AutomatizacionState, clave
 * `traspaso:<codigo>:<etapa>`):
 *   - al llegar a Vendido     → actividad "Venta de {codigo} lista para Escrituración"
 *   - al llegar a Escriturado → actividad "{codigo} escriturado: pasa a SAC"
 * Una etapa alta implica las anteriores (p. ej. Escriturado cubre Vendido).
 *
 * Flags:
 *   --archivo <path>  JSON de etapas (default: reference/maestro/maestro-unidades.json)
 *   --dry-run         no escribe en Monday ni en la base; solo reporta
 *   --semilla         registra el dedup de traspasos SIN crear actividades.
 *                     Usarlo en la PRIMERA corrida (carga histórica): las ~50
 *                     unidades ya vendidas/escrituradas no deben generar
 *                     actividades retroactivas. Las corridas siguientes (sin
 *                     --semilla) solo crean actividad en transiciones nuevas.
 *
 * Uso: npm run sync:etapas -- [--archivo <path>] [--dry-run] [--semilla]
 */
import { readFile } from 'node:fs/promises'
import path from 'node:path'
import { fileURLToPath } from 'node:url'
import { config } from '../src/config/index.js'
import { MondayService } from '../src/services/monday.service.js'
import { ETAPAS_PIPELINE, normalizarEtapa, rangoEtapa, TRASPASOS, type EtapaPipeline } from '../src/services/etapas.js'
import { prisma } from '../src/services/prisma.js'

const RAIZ = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..')
const ARCHIVO_DEFAULT = path.join(RAIZ, 'reference/maestro/maestro-unidades.json')
const PAUSA_MS = 400 // entre mutaciones, para no pegarle al rate limit de Monday

const sleep = (ms: number): Promise<void> => new Promise((r) => setTimeout(r, ms))

// ---------- Argumentos ----------

interface Opciones {
  archivo: string
  dryRun: boolean
  semilla: boolean
}

function parseArgs(argv: string[]): Opciones {
  const ops: Opciones = { archivo: ARCHIVO_DEFAULT, dryRun: false, semilla: false }
  for (let i = 0; i < argv.length; i++) {
    const arg = argv[i]
    if (arg === '--dry-run') ops.dryRun = true
    else if (arg === '--semilla') ops.semilla = true
    else if (arg === '--archivo') {
      const valor = argv[++i]
      if (!valor) throw new Error('--archivo requiere una ruta')
      ops.archivo = path.resolve(process.cwd(), valor)
    } else {
      throw new Error(`Argumento desconocido: ${arg}`)
    }
  }
  return ops
}

// ---------- Entrada ----------

interface EtapaUnidad {
  codigo: string
  etapa: EtapaPipeline // ya normalizada al label oficial
}

interface EntradaMaestro {
  codigo_nuestro?: string | null
  etapa_maestro?: string | null
  mapeo?: { confianza?: string }
}

interface EntradaSimple {
  codigo?: string
  etapa?: string | null
}

/** Lee el JSON de etapas y lo deja en pares {codigo, etapa oficial}; avisa lo que descarta */
async function cargarEtapas(archivo: string): Promise<EtapaUnidad[]> {
  const json = JSON.parse(await readFile(archivo, 'utf8')) as unknown[]
  if (!Array.isArray(json)) throw new Error(`${archivo} no es un array JSON`)
  const esMaestro = json.some((e) => typeof e === 'object' && e !== null && 'codigo_nuestro' in e)
  const out: EtapaUnidad[] = []
  let descartadas = 0
  for (const cruda of json) {
    if (typeof cruda !== 'object' || cruda === null) {
      descartadas++
      continue
    }
    let codigo: string | undefined
    let etapaCruda: string | null | undefined
    if (esMaestro) {
      const e = cruda as EntradaMaestro
      const confianza = e.mapeo?.confianza ?? 'ninguna'
      if (confianza !== 'alta' && confianza !== 'media') {
        descartadas++
        continue
      }
      codigo = e.codigo_nuestro ?? undefined
      etapaCruda = e.etapa_maestro
    } else {
      const e = cruda as EntradaSimple
      codigo = e.codigo
      etapaCruda = e.etapa
    }
    if (!codigo) {
      descartadas++
      continue
    }
    const etapa = normalizarEtapa(etapaCruda)
    if (etapa === null) {
      // DISPONIBLE / vacío / desconocido: la unidad no tiene etapa del pipeline;
      // no se escribe nada (nunca se borra una etapa existente desde este script)
      descartadas++
      continue
    }
    out.push({ codigo, etapa })
  }
  if (descartadas > 0) console.log(`  (${descartadas} entradas descartadas: sin match, sin etapa o confianza baja)`)
  return out
}

// ---------- Monday: columna Etapa ----------

const monday = new MondayService()

interface ColumnaBoard {
  id: string
  title: string
  type: string
  settings_str?: string
}

async function columnasDe(boardId: string): Promise<ColumnaBoard[]> {
  const data = await monday.graphql<{ boards: { columns: ColumnaBoard[] }[] }>(
    `query ($ids: [ID!]) { boards(ids: $ids) { columns { id title type settings_str } } }`,
    { ids: [boardId] },
  )
  return data.boards[0]?.columns ?? []
}

/** Labels actuales de una columna status (de settings_str: {"labels":{"0":"Apartado",...}}) */
function labelsDe(col: ColumnaBoard): Set<string> {
  try {
    const settings = JSON.parse(col.settings_str ?? '{}') as { labels?: Record<string, string> }
    return new Set(Object.values(settings.labels ?? {}))
  } catch {
    return new Set()
  }
}

/**
 * Garantiza que exista la columna status "Etapa" con los 10 labels oficiales.
 * Monday no crea labels vía defaults de create_column en este workspace, así
 * que los labels faltantes se siembran escribiéndolos en un item scratch con
 * create_labels_if_missing:true y borrando el item al final.
 */
async function asegurarColumnaEtapa(boardId: string, dryRun: boolean): Promise<void> {
  let col = (await columnasDe(boardId)).find((c) => c.title === 'Etapa')
  if (col && col.type !== 'status') throw new Error(`La columna "Etapa" existe pero es tipo ${col.type}, no status`)
  if (!col) {
    if (dryRun) {
      console.log('  [dry-run] se crearía la columna "Etapa" (status) con los 10 labels')
      return
    }
    await monday.graphql(
      `mutation ($boardId: ID!, $title: String!, $tipo: ColumnType!) {
         create_column(board_id: $boardId, title: $title, column_type: $tipo) { id }
       }`,
      { boardId, title: 'Etapa', tipo: 'status' },
    )
    console.log('  + columna "Etapa" creada')
    col = (await columnasDe(boardId)).find((c) => c.title === 'Etapa')
    if (!col) throw new Error('No se encontró la columna "Etapa" recién creada')
  }

  const faltantes = ETAPAS_PIPELINE.filter((l) => !labelsDe(col).has(l))
  if (faltantes.length === 0) {
    console.log('  columna "Etapa" ya tiene los 10 labels')
    return
  }
  if (dryRun) {
    console.log(`  [dry-run] faltarían labels en "Etapa": ${faltantes.join(', ')}`)
    return
  }
  const creado = await monday.graphql<{ create_item: { id: string } }>(
    `mutation ($boardId: ID!, $name: String!) { create_item(board_id: $boardId, item_name: $name) { id } }`,
    { boardId, name: 'tmp-sync-etapas (borrar)' },
  )
  const scratchId = creado.create_item.id
  try {
    for (const label of faltantes) {
      await monday.graphql(
        `mutation ($boardId: ID!, $itemId: ID!, $values: JSON!) {
           change_multiple_column_values(board_id: $boardId, item_id: $itemId, column_values: $values, create_labels_if_missing: true) { id }
         }`,
        { boardId, itemId: scratchId, values: JSON.stringify({ [col.id]: { label } }) },
      )
      await sleep(PAUSA_MS)
    }
  } finally {
    await monday.graphql(`mutation ($itemId: ID!) { delete_item(item_id: $itemId) { id } }`, { itemId: scratchId })
  }
  console.log(`  + labels sembrados en "Etapa": ${faltantes.join(', ')}`)
}

// ---------- Traspasos de departamento ----------

const claveDedup = (codigo: string, etapa: string): string => `traspaso:${codigo}:${etapa}`

const nombreActividad = (codigo: string, etapa: EtapaPipeline): string =>
  etapa === 'Vendido' ? `Venta de ${codigo} lista para Escrituración` : `${codigo} escriturado: pasa a SAC`

const fechaHoy = (): string => new Date().toISOString().slice(0, 10)

interface ResumenTraspasos {
  actividadesCreadas: number
  registradasSemilla: number
  yaRegistradas: number
  errores: number
}

/**
 * Para la etapa vigente de una unidad, cubre los traspasos (Vendido →
 * Escrituración, Escriturado → SAC) con rango <= la etapa, con dedup persistente.
 */
async function cubrirTraspasos(
  codigo: string,
  etapaVigente: EtapaPipeline,
  ops: Opciones,
  resumen: ResumenTraspasos,
): Promise<void> {
  const rango = rangoEtapa(etapaVigente)
  for (const [etapaTraspaso, depto] of Object.entries(TRASPASOS) as [EtapaPipeline, string][]) {
    if (rangoEtapa(etapaTraspaso) > rango) continue
    const clave = claveDedup(codigo, etapaTraspaso)
    const ya = await prisma.automatizacionState.findUnique({ where: { clave } })
    if (ya) {
      resumen.yaRegistradas++
      continue
    }
    if (ops.dryRun) {
      console.log(`  [dry-run] traspaso pendiente: ${codigo} → ${depto} (${ops.semilla ? 'se registraría sin actividad' : 'crearía actividad'})`)
      continue
    }
    if (ops.semilla) {
      await prisma.automatizacionState.upsert({
        where: { clave },
        update: { valor: 'semilla' },
        create: { clave, valor: 'semilla' },
      })
      resumen.registradasSemilla++
      continue
    }
    try {
      await monday.crearActividad({
        nombre: nombreActividad(codigo, etapaTraspaso),
        tipoLabel: 'Tarea',
        fecha: fechaHoy(),
        estadoLabel: 'Abierto',
        responsableId: config.automatizaciones.coordinadorUserId > 0 ? config.automatizaciones.coordinadorUserId : undefined,
      })
      await prisma.automatizacionState.upsert({
        where: { clave },
        update: { valor: 'actividad-creada' },
        create: { clave, valor: 'actividad-creada' },
      })
      resumen.actividadesCreadas++
      console.log(`  + actividad: ${nombreActividad(codigo, etapaTraspaso)}`)
      await sleep(PAUSA_MS)
    } catch (err) {
      // Sin dedup: la próxima corrida reintenta la actividad
      resumen.errores++
      console.error(`  ! no se pudo crear la actividad de traspaso de ${codigo}:`, err instanceof Error ? err.message : err)
    }
  }
}

// ---------- Main ----------

async function main(): Promise<void> {
  const ops = parseArgs(process.argv.slice(2))
  const boardId = config.monday.boards.unidades
  console.log(`sync-etapas: ${ops.archivo}${ops.dryRun ? ' [dry-run]' : ''}${ops.semilla ? ' [semilla]' : ''}`)

  await asegurarColumnaEtapa(boardId, ops.dryRun)

  const entradas = await cargarEtapas(ops.archivo)
  console.log(`  ${entradas.length} unidades con etapa en el archivo`)

  const unidades = await monday.getUnidades()
  const porCodigo = new Map(unidades.map((u) => [u.codigo, u]))

  let escritas = 0
  let sinCambio = 0
  const noEncontradas: string[] = []
  const resumenTraspasos: ResumenTraspasos = { actividadesCreadas: 0, registradasSemilla: 0, yaRegistradas: 0, errores: 0 }

  for (const { codigo, etapa } of entradas) {
    const unidad = porCodigo.get(codigo)
    if (!unidad) {
      noEncontradas.push(codigo)
      continue
    }
    const etapaActual = normalizarEtapa(unidad.etapa)
    if (etapaActual !== etapa) {
      if (ops.dryRun) {
        console.log(`  [dry-run] ${codigo}: ${unidad.etapa ?? '(vacío)'} → ${etapa}`)
      } else {
        const itemId = await monday.itemIdDeUnidad(codigo)
        if (!itemId) {
          noEncontradas.push(codigo)
          continue
        }
        await monday.cambiarValorColumna(boardId, itemId, 'Etapa', etapa)
        escritas++
        console.log(`  = ${codigo}: ${unidad.etapa ?? '(vacío)'} → ${etapa}`)
        await sleep(PAUSA_MS)
      }
    } else {
      sinCambio++
    }
    await cubrirTraspasos(codigo, etapa, ops, resumenTraspasos)
  }

  console.log('\nResumen:')
  console.log(`  etapas escritas:        ${escritas}${ops.dryRun ? ' (dry-run: 0 reales)' : ''}`)
  console.log(`  sin cambio:             ${sinCambio}`)
  console.log(`  no encontradas:         ${noEncontradas.length}${noEncontradas.length > 0 ? ` (${noEncontradas.join(', ')})` : ''}`)
  console.log(`  actividades creadas:    ${resumenTraspasos.actividadesCreadas}`)
  console.log(`  traspasos sembrados:    ${resumenTraspasos.registradasSemilla}`)
  console.log(`  traspasos ya dedup:     ${resumenTraspasos.yaRegistradas}`)
  if (resumenTraspasos.errores > 0) console.log(`  ERRORES en actividades: ${resumenTraspasos.errores}`)

  // Conteo final por etapa (lectura fresca del board)
  if (!ops.dryRun) {
    monday.invalidarCacheUnidades()
    const frescas = await monday.getUnidades()
    const conteo = new Map<string, number>()
    for (const u of frescas) {
      const e = normalizarEtapa(u.etapa)
      if (e) conteo.set(e, (conteo.get(e) ?? 0) + 1)
    }
    console.log('\nUnidades por etapa (board):')
    for (const etapa of ETAPAS_PIPELINE) {
      const n = conteo.get(etapa) ?? 0
      if (n > 0) console.log(`  ${etapa}: ${n}`)
    }
    const sinEtapa = frescas.length - [...conteo.values()].reduce((a, b) => a + b, 0)
    console.log(`  (sin etapa): ${sinEtapa}`)
  }
  await prisma.$disconnect()
}

main().catch((err) => {
  console.error('sync-etapas falló:', err)
  process.exit(1)
})