import { describe, expect, it, vi } from 'vitest'
import { config } from '../config/index.js'
import {
  AutomatizacionesService,
  claveApartadoCreado,
  claveEscalado,
  claveRecordatorio,
  claveVentaCreada,
  esEstadoTerminal,
  esEtapa,
  ESTADOS_TERMINALES_LEAD,
  oportunidadesInactivas,
  oportunidadesSinContactar,
  parseRrUserIds,
  vendedorEnTurno,
  type StateStore,
} from './automatizaciones.service.js'
import type { LeadMonday, OportunidadMonday, UsuarioMonday } from './monday.service.js'

// ---------- Fixtures ----------

const VENDEDORES: UsuarioMonday[] = [
  { id: 101, nombre: 'Ana', email: 'ana@x.com' },
  { id: 102, nombre: 'Beto', email: 'beto@x.com' },
  { id: 103, nombre: 'Carla', email: 'carla@x.com' },
]

function lead(id: string, overrides: Partial<LeadMonday> = {}): LeadMonday {
  return {
    id,
    nombre: `Lead ${id}`,
    createdAt: '2026-08-01T09:00:00Z',
    updatedAt: '2026-08-01T10:00:00Z',
    estado: 'Nuevo',
    origen: '',
    vendedorIds: [],
    telefono: '',
    email: '',
    ...overrides,
  }
}

function oportunidad(id: string, overrides: Partial<OportunidadMonday> = {}): OportunidadMonday {
  return {
    id,
    nombre: `Cliente ${id}`,
    createdAt: '2026-08-01T09:00:00Z',
    updatedAt: '2026-08-01T10:00:00Z',
    etapa: 'Afluencia',
    unidadCodigo: 'U-101',
    precioFinal: 2500000,
    asesorIds: [],
    telefono: '',
    email: '',
    origen: '',
    ...overrides,
  }
}

/** StateStore en memoria para tests (sin Prisma) */
function stateEnMemoria(): StateStore & { mapa: Map<string, string> } {
  const mapa = new Map<string, string>()
  return {
    mapa,
    async get(clave) {
      return mapa.get(clave) ?? null
    },
    async set(clave, valor) {
      mapa.set(clave, valor)
    },
  }
}

/** Monday mockeado: leads y oportunidades fijos, registra asignaciones, updates y actividades */
function mondayMock(leads: LeadMonday[] = [], oportunidades: OportunidadMonday[] = []) {
  return {
    asignaciones: [] as { itemId: string; userId: number; tablero: string }[],
    updates: [] as { itemId: string; body: string }[],
    actividades: [] as {
      nombre: string
      tipoLabel: string
      responsableId: number
      fecha: string
      estadoLabel: string
      leadItemId: string
    }[],
    apartados: [] as Record<string, unknown>[],
    ventas: [] as Record<string, unknown>[],
    async getLeads() {
      return leads
    },
    async getOportunidades() {
      return oportunidades
    },
    async asignarVendedorALead(itemId: string, userId: number) {
      this.asignaciones.push({ itemId, userId, tablero: 'leads' })
    },
    async asignarAsesorAOportunidad(itemId: string, userId: number) {
      this.asignaciones.push({ itemId, userId, tablero: 'oportunidades' })
    },
    async crearUpdateEnItem(itemId: string, body: string) {
      this.updates.push({ itemId, body })
      return 'upd-1'
    },
    async crearActividad(datos: {
      nombre: string
      tipoLabel: string
      responsableId: number
      fecha: string
      estadoLabel: string
      leadItemId: string
    }) {
      this.actividades.push(datos)
      return 'act-1'
    },
    async crearApartado(datos: Record<string, unknown>) {
      this.apartados.push(datos)
      return `apt-${this.apartados.length}`
    },
    async crearVenta(datos: Record<string, unknown>) {
      this.ventas.push(datos)
      return `vta-${this.ventas.length}`
    },
    async getUsuariosEquipo(_nombre: string) {
      return VENDEDORES
    },
  }
}

const crearServicio = (monday: ReturnType<typeof mondayMock>, state: StateStore) =>
  new AutomatizacionesService(monday, state)

// ---------- Lógica pura ----------

describe('parseRrUserIds', () => {
  it('parsea IDs separados por coma ignorando espacios y vacíos', () => {
    expect(parseRrUserIds(' 106735975, 106735976 ,, ')).toEqual([
      { id: 106735975, nombre: 'Usuario 106735975', email: '' },
      { id: 106735976, nombre: 'Usuario 106735976', email: '' },
    ])
    expect(parseRrUserIds('')).toEqual([])
  })

  it('lanza error con IDs inválidos', () => {
    expect(() => parseRrUserIds('123,abc')).toThrow(/inválido/)
    expect(() => parseRrUserIds('-5')).toThrow(/inválido/)
  })
})

describe('esEstadoTerminal (terminales por tablero)', () => {
  it('Ganado / Perdido / Abandono son terminales en Oportunidades (default)', () => {
    expect(esEstadoTerminal('GANADO')).toBe(true)
    expect(esEstadoTerminal(' perdido ')).toBe(true)
    expect(esEstadoTerminal('Abandono')).toBe(true)
    expect(esEstadoTerminal('Afluencia')).toBe(false)
    expect(esEstadoTerminal('Contactado')).toBe(false)
    expect(esEstadoTerminal('Intento de contacto')).toBe(false)
    expect(esEstadoTerminal('')).toBe(false)
  })

  it('Descartado / Calificado / Abandono son terminales en Leads (title case, case-insensitive)', () => {
    expect(esEstadoTerminal('Descartado', ESTADOS_TERMINALES_LEAD)).toBe(true)
    expect(esEstadoTerminal('calificado', ESTADOS_TERMINALES_LEAD)).toBe(true)
    expect(esEstadoTerminal('ABANDONO', ESTADOS_TERMINALES_LEAD)).toBe(true)
    expect(esEstadoTerminal('Nuevo', ESTADOS_TERMINALES_LEAD)).toBe(false)
    expect(esEstadoTerminal('Contactado', ESTADOS_TERMINALES_LEAD)).toBe(false)
  })
})

describe('vendedorEnTurno (rotación round-robin)', () => {
  it('rota circularmente por la lista', () => {
    expect(vendedorEnTurno(VENDEDORES, 0)?.id).toBe(101)
    expect(vendedorEnTurno(VENDEDORES, 1)?.id).toBe(102)
    expect(vendedorEnTurno(VENDEDORES, 2)?.id).toBe(103)
    expect(vendedorEnTurno(VENDEDORES, 3)?.id).toBe(101) // wraparound
    expect(vendedorEnTurno(VENDEDORES, 7)?.id).toBe(102)
  })

  it('devuelve undefined con lista vacía', () => {
    expect(vendedorEnTurno([], 0)).toBeUndefined()
  })
})

describe('oportunidadesInactivas', () => {
  const ahora = new Date('2026-08-22T00:00:00Z')

  it('incluye oportunidades en etapa temprana CON asesor que superan el umbral de días', () => {
    const ops = [
      oportunidad('1', { updatedAt: '2026-08-10T00:00:00Z', asesorIds: [101] }), // 12 días → inactiva (umbral 10)
      oportunidad('2', { updatedAt: '2026-08-20T00:00:00Z', asesorIds: [101] }), // 2 días → activa
      oportunidad('3', { updatedAt: '2026-07-01T00:00:00Z', asesorIds: [101], etapa: 'Perdido' }), // terminal → excluida
      oportunidad('4', { updatedAt: '2026-07-01T00:00:00Z' }), // sin asesor → excluida
      oportunidad('5', { updatedAt: '2026-07-01T00:00:00Z', asesorIds: [101], etapa: 'Cotizador' }), // etapa avanzada → excluida
      oportunidad('6', { updatedAt: '2026-08-01T00:00:00Z', asesorIds: [101], etapa: 'Contactado' }), // 21 días → inactiva
    ]
    const inactivas = oportunidadesInactivas(ops, ahora, 10)
    expect(inactivas.map((o) => o.id)).toEqual(['1', '6'])
  })

  it('una oportunidad actualizada hace exactamente N días aún no supera el umbral', () => {
    const ops = [oportunidad('1', { updatedAt: '2026-08-12T00:00:00Z', asesorIds: [101] })] // justo 10 días
    expect(oportunidadesInactivas(ops, ahora, 10)).toEqual([])
  })

  it('ignora fechas inválidas', () => {
    expect(oportunidadesInactivas([oportunidad('1', { updatedAt: 'no-es-fecha', asesorIds: [101] })], ahora, 10)).toEqual([])
  })
})

describe('claveRecordatorio (dedup por día)', () => {
  it('una clave por oportunidad por día', () => {
    expect(claveRecordatorio('123', new Date('2026-08-22T09:00:00Z'))).toBe('recordatorio:123:2026-08-22')
    expect(claveRecordatorio('123', new Date('2026-08-22T23:59:00Z'))).toBe('recordatorio:123:2026-08-22')
    expect(claveRecordatorio('123', new Date('2026-08-23T00:00:00Z'))).toBe('recordatorio:123:2026-08-23')
  })
})

// ---------- Servicio (monday mockeado, sin red) ----------

describe('AutomatizacionesService.runRoundRobin', () => {
  it('asigna en rotación sobre AMBOS tableros y persiste el índice (Leads → Vendedor, Oportunidades → Asesor)', async () => {
    const monday = mondayMock([lead('l1'), lead('l2')], [oportunidad('o1'), oportunidad('o2')])
    const state = stateEnMemoria()
    const svc = crearServicio(monday, state)

    const r1 = await svc.runRoundRobin()
    expect(r1.asignados).toBe(4)
    expect(monday.asignaciones).toEqual([
      { itemId: 'l1', userId: 101, tablero: 'leads' },
      { itemId: 'l2', userId: 102, tablero: 'leads' },
      { itemId: 'o1', userId: 103, tablero: 'oportunidades' },
      { itemId: 'o2', userId: 101, tablero: 'oportunidades' },
    ])
    expect(r1.detalle.map((d) => d.tablero)).toEqual(['leads', 'leads', 'oportunidades', 'oportunidades'])
    expect(state.mapa.get('rr:indice')).toBe('1') // 4 asignaciones % 3 vendedores

    // Segunda pasada con una afluencia nueva: continúa donde quedó (no reinicia en 0)
    const monday2 = mondayMock([], [oportunidad('o5')])
    const svc2 = new AutomatizacionesService(monday2, state)
    const r2 = await svc2.runRoundRobin()
    expect(r2.asignados).toBe(1)
    expect(monday2.asignaciones[0]?.userId).toBe(102)
    expect(state.mapa.get('rr:indice')).toBe('2')
  })

  it('Leads: reparte los sin Vendedor y no terminales (labels title case, case-insensitive)', async () => {
    const monday = mondayMock([
      lead('1'),
      lead('2', { vendedorIds: [101] }), // ya asignado
      lead('3', { estado: 'Descartado' }), // terminal
      lead('4', { estado: 'Calificado' }), // terminal
      lead('5', { estado: 'Contactado' }), // en seguimiento: sí entra
    ])
    const svc = crearServicio(monday, stateEnMemoria())
    const r = await svc.runRoundRobin(undefined, 'leads')
    expect(r.asignados).toBe(2)
    expect(monday.asignaciones).toEqual([
      { itemId: '1', userId: 101, tablero: 'leads' },
      { itemId: '5', userId: 102, tablero: 'leads' },
    ])
  })

  it('Oportunidades: solo reparte etapa Afluencia (Cotizador/Contactado NO entran)', async () => {
    const monday = mondayMock([], [
      oportunidad('1'),
      oportunidad('2', { asesorIds: [101] }), // ya asignada
      oportunidad('3', { etapa: 'Cotizador' }), // creada por el cotizador: no entra
      oportunidad('4', { etapa: 'Contactado' }), // ya en seguimiento: no entra
      oportunidad('5', { etapa: 'Perdido' }), // terminal: no entra
      oportunidad('6', { etapa: 'afluencia' }), // case-insensitive: sí entra
    ])
    const svc = crearServicio(monday, stateEnMemoria())
    const r = await svc.runRoundRobin(undefined, 'oportunidades')
    expect(r.asignados).toBe(2)
    expect(monday.asignaciones).toEqual([
      { itemId: '1', userId: 101, tablero: 'oportunidades' },
      { itemId: '6', userId: 102, tablero: 'oportunidades' },
    ])
  })

  it('omite items con bandera rr:skip=capturista (los asigna su capturista)', async () => {
    const monday = mondayMock([lead('1')], [oportunidad('2')])
    const state = stateEnMemoria()
    state.mapa.set('rr:skip:1', 'capturista') // el capturista lo asigna
    state.mapa.set('rr:skip:2', 'round-robin') // bandera liberada: sí entra al reparto
    const svc = crearServicio(monday, state)
    const r = await svc.runRoundRobin()
    expect(r.asignados).toBe(1)
    expect(monday.asignaciones).toEqual([{ itemId: '2', userId: 101, tablero: 'oportunidades' }])
  })

  it('con soloItemId + board solo evalúa ese item (ruta de los webhooks create_item)', async () => {
    const monday = mondayMock([lead('1'), lead('2')], [oportunidad('9')])
    const svc = crearServicio(monday, stateEnMemoria())
    const r = await svc.runRoundRobin('2', 'leads')
    expect(r.asignados).toBe(1)
    expect(monday.asignaciones).toEqual([{ itemId: '2', userId: 101, tablero: 'leads' }])
  })

  it('con soloItemId de otro tablero no asigna nada', async () => {
    const monday = mondayMock([lead('1')], [oportunidad('9')])
    const svc = crearServicio(monday, stateEnMemoria())
    const r = await svc.runRoundRobin('9', 'leads') // '9' no está en Leads
    expect(r.asignados).toBe(0)
    expect(monday.asignaciones).toEqual([])
  })

  it('cachea los vendedores del equipo en el estado (una sola llamada dentro del TTL)', async () => {
    const monday = mondayMock()
    const spy = vi.spyOn(monday, 'getUsuariosEquipo')
    const state = stateEnMemoria()
    const svc = crearServicio(monday, state)
    const v1 = await svc.obtenerVendedores()
    const v2 = await svc.obtenerVendedores()
    expect(v1.map((v) => v.id)).toEqual([101, 102, 103])
    expect(v2).toEqual(v1)
    expect(spy).toHaveBeenCalledTimes(1)
    expect(spy.mock.calls[0]?.[0]).toBe('vendedores') // equipo por default
  })

  it('cache con formato viejo (arreglo sin ts) se descarta y re-consulta', async () => {
    const monday = mondayMock()
    const spy = vi.spyOn(monday, 'getUsuariosEquipo')
    const state = stateEnMemoria()
    state.mapa.set('rr:vendedores', JSON.stringify([{ id: 999, nombre: 'Viejo', email: '' }]))
    const svc = crearServicio(monday, state)
    const v = await svc.obtenerVendedores()
    expect(v.map((x) => x.id)).toEqual([101, 102, 103])
    expect(spy).toHaveBeenCalledTimes(1)
  })
})

describe('AutomatizacionesService.escaneoInactividad', () => {
  const ahora = new Date('2026-08-22T09:00:00Z')
  const oportunidadesViejas = () => [
    oportunidad('1', { updatedAt: '2026-08-01T00:00:00Z', asesorIds: [101] }), // 21 días inactiva
    oportunidad('2', { updatedAt: '2026-08-20T00:00:00Z', asesorIds: [101] }), // activa
  ]

  it('preview: lista candidatos sin escribir en Monday ni en el estado', async () => {
    const monday = mondayMock([], oportunidadesViejas())
    const state = stateEnMemoria()
    const svc = crearServicio(monday, state)

    const r = await svc.escaneoInactividad({ preview: true, ahora })
    expect(r.preview).toBe(true)
    expect(r.candidatos.map((c) => c.itemId)).toEqual(['1'])
    expect(r.candidatos[0]?.diasInactivo).toBe(21)
    expect(r.recordatoriosEnviados).toBe(0)
    expect(monday.updates).toEqual([])
    expect(state.mapa.size).toBe(0) // preview no persiste nada
  })

  it('ejecución real: crea update, marca dedup y no repite el mismo día', async () => {
    const monday = mondayMock([], oportunidadesViejas())
    const state = stateEnMemoria()
    const svc = crearServicio(monday, state)

    const r1 = await svc.escaneoInactividad({ preview: false, ahora })
    expect(r1.recordatoriosEnviados).toBe(1)
    expect(monday.updates).toHaveLength(1)
    expect(monday.updates[0]?.body).toContain('21 días')
    expect(state.mapa.get('recordatorio:1:2026-08-22')).toBeDefined()

    // Mismo día: no repite aunque la oportunidad siga inactiva
    const r2 = await svc.escaneoInactividad({ preview: false, ahora: new Date('2026-08-22T18:00:00Z') })
    expect(r2.recordatoriosEnviados).toBe(0)
    expect(r2.candidatos[0]?.yaRecordadoHoy).toBe(true)
    expect(monday.updates).toHaveLength(1)

    // Al día siguiente vuelve a recordar
    const r3 = await svc.escaneoInactividad({ preview: false, ahora: new Date('2026-08-23T09:00:00Z') })
    expect(r3.recordatoriosEnviados).toBe(1)
    expect(monday.updates).toHaveLength(2)
  })
})

// ---------- Actividades automáticas (tablero Actividades del CRM) ----------

describe('Actividades automáticas (ACTIVIDADES_ENABLED)', () => {
  const ahora = new Date('2026-08-22T09:00:00Z')

  it('el round-robin crea "Contactar a {nombre}" tipo Llamada, Abierto, ligada a la oportunidad', async () => {
    const monday = mondayMock([], [oportunidad('1'), oportunidad('2')])
    const svc = new AutomatizacionesService(monday, stateEnMemoria(), { actividadesEnabled: true })

    const r = await svc.runRoundRobin()
    expect(r.asignados).toBe(2)
    expect(monday.actividades).toHaveLength(2)
    expect(monday.actividades[0]).toMatchObject({
      nombre: 'Contactar a Cliente 1',
      tipoLabel: 'Llamada',
      responsableId: 101,
      estadoLabel: 'Abierto',
      leadItemId: '1',
    })
    // Fecha compromiso: hoy + 1 día (fecha local, como la construye el servicio)
    const esperada = new Date()
    esperada.setDate(esperada.getDate() + 1)
    const m = String(esperada.getMonth() + 1).padStart(2, '0')
    const d = String(esperada.getDate()).padStart(2, '0')
    expect(monday.actividades[0]?.fecha).toBe(`${esperada.getFullYear()}-${m}-${d}`)
    expect(monday.actividades[1]?.responsableId).toBe(102)
  })

  it('con actividadesEnabled=false el round-robin no crea actividades', async () => {
    const monday = mondayMock([], [oportunidad('1')])
    const svc = new AutomatizacionesService(monday, stateEnMemoria(), { actividadesEnabled: false })
    await svc.runRoundRobin()
    expect(monday.actividades).toEqual([])
  })

  it('asignarACapturista: asigna al capturista (columna Asesor) y le crea su actividad de contacto', async () => {
    const monday = mondayMock([])
    const svc = new AutomatizacionesService(monday, stateEnMemoria(), { actividadesEnabled: true })

    await svc.asignarACapturista('op-77', 'Lead Propio', 555)

    expect(monday.asignaciones).toEqual([{ itemId: 'op-77', userId: 555, tablero: 'oportunidades' }])
    expect(monday.actividades[0]).toMatchObject({
      nombre: 'Contactar a Lead Propio',
      responsableId: 555,
      estadoLabel: 'Abierto',
      leadItemId: 'op-77',
    })
  })

  it('asignarACapturista con board "leads" escribe la columna Vendedor del tablero Leads', async () => {
    const monday = mondayMock([])
    const svc = new AutomatizacionesService(monday, stateEnMemoria(), { actividadesEnabled: true })

    await svc.asignarACapturista('lead-77', 'Lead Propio', 555, 'leads')

    expect(monday.asignaciones).toEqual([{ itemId: 'lead-77', userId: 555, tablero: 'leads' }])
    expect(monday.actividades[0]).toMatchObject({ nombre: 'Contactar a Lead Propio', leadItemId: 'lead-77' })
  })

  it('asignarACapturista con actividadesEnabled=false solo asigna', async () => {
    const monday = mondayMock([])
    const svc = new AutomatizacionesService(monday, stateEnMemoria(), { actividadesEnabled: false })

    await svc.asignarACapturista('op-78', 'Lead Propio', 555)

    expect(monday.asignaciones).toEqual([{ itemId: 'op-78', userId: 555, tablero: 'oportunidades' }])
    expect(monday.actividades).toEqual([])
  })

  it('inactividad: crea "Retomar contacto" al asesor asignado; las candidatas siempre tienen asesor', async () => {
    const monday = mondayMock([], [oportunidad('1', { updatedAt: '2026-08-01T00:00:00Z', asesorIds: [103] })])
    const svc = new AutomatizacionesService(monday, stateEnMemoria(), { actividadesEnabled: true })

    const r = await svc.escaneoInactividad({ preview: false, ahora })
    expect(r.recordatoriosEnviados).toBe(1)
    expect(monday.actividades).toHaveLength(1)
    expect(monday.actividades[0]).toMatchObject({
      nombre: 'Retomar contacto con Cliente 1',
      tipoLabel: 'Llamada',
      responsableId: 103,
      estadoLabel: 'Abierto',
      leadItemId: '1',
    })
  })

  it('preview de inactividad no crea actividades', async () => {
    const monday = mondayMock([], [oportunidad('1', { updatedAt: '2026-08-01T00:00:00Z', asesorIds: [101] })])
    const svc = new AutomatizacionesService(monday, stateEnMemoria(), { actividadesEnabled: true })
    await svc.escaneoInactividad({ preview: true, ahora })
    expect(monday.actividades).toEqual([])
  })

  it('un fallo al crear la actividad no rompe la asignación', async () => {
    const monday = mondayMock([], [oportunidad('1')])
    vi.spyOn(monday, 'crearActividad').mockRejectedValueOnce(new Error('Monday caído'))
    const spyError = vi.spyOn(console, 'error').mockImplementation(() => {})
    const svc = new AutomatizacionesService(monday, stateEnMemoria(), { actividadesEnabled: true })

    const r = await svc.runRoundRobin()
    expect(r.asignados).toBe(1) // la asignación se hizo igual
    expect(monday.asignaciones).toEqual([{ itemId: '1', userId: 101, tablero: 'oportunidades' }])
    spyError.mockRestore()
  })
})

// ---------- Escalado de afluencias sin contactar ----------

describe('oportunidadesSinContactar (regla de escalado por horas)', () => {
  const ahora = new Date('2026-08-22T12:00:00Z')

  it('incluye oportunidades asignadas en Afluencia / Intento de contacto que superan el umbral', () => {
    const ops = [
      oportunidad('1', { asesorIds: [101], updatedAt: '2026-08-19T12:00:00Z' }), // 72 h → escala
      oportunidad('2', { asesorIds: [102], etapa: 'Intento de contacto', updatedAt: '2026-08-20T12:00:00Z' }), // 48 h justo → no
      oportunidad('3', { asesorIds: [103], etapa: 'Contactado', updatedAt: '2026-08-01T12:00:00Z' }), // ya contactada
      oportunidad('4', { etapa: 'Afluencia', updatedAt: '2026-08-01T12:00:00Z' }), // sin asesor → no aplica
      oportunidad('5', { asesorIds: [101], etapa: 'Perdido', updatedAt: '2026-08-01T12:00:00Z' }), // terminal
    ]
    expect(oportunidadesSinContactar(ops, ahora, 48).map((o) => o.id)).toEqual(['1'])
  })

  it('una oportunidad con exactamente N horas aún no supera el umbral', () => {
    const ops = [oportunidad('1', { asesorIds: [101], updatedAt: '2026-08-20T12:00:00Z' })]
    expect(oportunidadesSinContactar(ops, ahora, 48)).toEqual([])
  })

  it('ignora fechas inválidas', () => {
    const ops = [oportunidad('1', { asesorIds: [101], updatedAt: 'no-es-fecha' })]
    expect(oportunidadesSinContactar(ops, ahora, 48)).toEqual([])
  })
})

describe('claves de dedup', () => {
  it('una clave por oportunidad', () => {
    expect(claveEscalado('123')).toBe('escalado:123')
    expect(claveApartadoCreado('456')).toBe('apartado-creado:456')
    expect(claveVentaCreada('456')).toBe('venta-creada:456')
  })
})

describe('esEtapa (detección de transición de etapa)', () => {
  it('compara tolerando mayúsculas y espacios', () => {
    expect(esEtapa('Aparto', 'APARTO')).toBe(true)
    expect(esEtapa(' ganado ', 'Ganado')).toBe(true)
    expect(esEtapa('Cotizador', 'Aparto')).toBe(false)
    expect(esEtapa('', 'Ganado')).toBe(false)
  })
})

describe('AutomatizacionesService.escaneoEscalado', () => {
  const ahora = new Date('2026-08-22T12:00:00Z')
  const configAuto = config.automatizaciones as Record<string, unknown>

  it('escala al asesor asignado cuando no hay coordinador configurado', async () => {
    const anterior = configAuto['coordinadorUserId']
    configAuto['coordinadorUserId'] = 0
    try {
      const monday = mondayMock([], [oportunidad('1', { asesorIds: [102], updatedAt: '2026-08-19T12:00:00Z' })])
      const state = stateEnMemoria()
      const svc = new AutomatizacionesService(monday, state, { actividadesEnabled: true })

      const r = await svc.escaneoEscalado({ ahora })
      expect(r.escalados).toBe(1)
      expect(r.candidatos[0]).toMatchObject({ itemId: '1', horasSinContactar: 72, responsableId: 102, yaEscalado: false })
      expect(monday.actividades[0]).toMatchObject({
        nombre: 'URGENTE: oportunidad sin contactar — Cliente 1',
        responsableId: 102,
        estadoLabel: 'Abierto',
        leadItemId: '1',
      })
      expect(monday.updates[0]?.body).toContain('72 h')
      expect(state.mapa.get('escalado:1')).toBeDefined()
      expect(state.mapa.get('contador:escalados')).toBe('1')
    } finally {
      configAuto['coordinadorUserId'] = anterior
    }
  })

  it('escala al coordinador cuando MONDAY_COORDINADOR_USER_ID está configurado', async () => {
    const anterior = configAuto['coordinadorUserId']
    configAuto['coordinadorUserId'] = 999
    try {
      const monday = mondayMock([], [oportunidad('1', { asesorIds: [102], updatedAt: '2026-08-19T12:00:00Z' })])
      const svc = new AutomatizacionesService(monday, stateEnMemoria(), { actividadesEnabled: true })
      const r = await svc.escaneoEscalado({ ahora })
      expect(r.escalados).toBe(1)
      expect(monday.actividades[0]?.responsableId).toBe(999)
      expect(r.candidatos[0]?.responsableId).toBe(999)
    } finally {
      configAuto['coordinadorUserId'] = anterior
    }
  })

  it('dedup: no vuelve a escalar una oportunidad ya escalada', async () => {
    const anterior = configAuto['coordinadorUserId']
    configAuto['coordinadorUserId'] = 0
    try {
      const monday = mondayMock([], [oportunidad('1', { asesorIds: [101], updatedAt: '2026-08-19T12:00:00Z' })])
      const state = stateEnMemoria()
      const svc = new AutomatizacionesService(monday, state, { actividadesEnabled: true })

      const r1 = await svc.escaneoEscalado({ ahora })
      expect(r1.escalados).toBe(1)
      const r2 = await svc.escaneoEscalado({ ahora: new Date('2026-08-23T12:00:00Z') })
      expect(r2.escalados).toBe(0)
      expect(r2.candidatos[0]?.yaEscalado).toBe(true)
      expect(monday.actividades).toHaveLength(1)
      expect(state.mapa.get('contador:escalados')).toBe('1')
    } finally {
      configAuto['coordinadorUserId'] = anterior
    }
  })

  it('un fallo de Monday en una oportunidad no detiene el escalado de las demás', async () => {
    const anterior = configAuto['coordinadorUserId']
    configAuto['coordinadorUserId'] = 0
    const spyError = vi.spyOn(console, 'error').mockImplementation(() => {})
    try {
      const monday = mondayMock([], [
        oportunidad('1', { asesorIds: [101], updatedAt: '2026-08-19T12:00:00Z' }),
        oportunidad('2', { asesorIds: [102], updatedAt: '2026-08-19T12:00:00Z' }),
      ])
      vi.spyOn(monday, 'crearUpdateEnItem')
        .mockRejectedValueOnce(new Error('Monday caído'))
        .mockResolvedValue('upd-ok')
      const svc = new AutomatizacionesService(monday, stateEnMemoria(), { actividadesEnabled: true })

      const r = await svc.escaneoEscalado({ ahora })
      expect(r.escalados).toBe(1) // la segunda oportunidad sí se escaló
      expect(r.candidatos).toHaveLength(2)
    } finally {
      configAuto['coordinadorUserId'] = anterior
      spyError.mockRestore()
    }
  })
})

// ---------- Oportunidad → Aparto / Ganado ----------

describe('AutomatizacionesService.escaneoOportunidades', () => {
  it('una oportunidad en Aparto crea su item en Apartado (estado Pago Apartado)', async () => {
    const monday = mondayMock([], [oportunidad('10', { etapa: 'Aparto' })])
    const state = stateEnMemoria()
    const svc = crearServicio(monday, state)

    const r = await svc.escaneoOportunidades()
    expect(r.apartadosCreados).toEqual([{ oportunidadId: '10', nombre: 'Cliente 10', apartadoItemId: 'apt-1' }])
    expect(monday.apartados[0]).toMatchObject({
      clienteNombre: 'Cliente 10',
      unidadCodigo: 'U-101',
      estadoLabel: 'Pago Apartado',
    })
    expect(state.mapa.get('apartado-creado:10')).toBe('apt-1')
    expect(state.mapa.get('contador:apartadosCreados')).toBe('1')
  })

  it('el Apartado hereda de la oportunidad: contacto, Precio Final y Vendedor (primer asesor)', async () => {
    const monday = mondayMock([], [
      oportunidad('10', { etapa: 'Aparto', telefono: '6641112233', email: 'c@c.com', asesorIds: [101, 102] }),
    ])
    const state = stateEnMemoria()
    const svc = crearServicio(monday, state)

    const r = await svc.escaneoOportunidades()
    expect(r.apartadosCreados).toHaveLength(1)
    expect(monday.apartados[0]).toMatchObject({
      clienteNombre: 'Cliente 10',
      unidadCodigo: 'U-101',
      telefono: '6641112233',
      email: 'c@c.com',
      precioFinal: 2500000,
      vendedorId: 101,
    })
  })

  it('una oportunidad en Ganado crea su item en Ventas con unidad y valor', async () => {
    const monday = mondayMock([], [oportunidad('11', { etapa: 'GANADO' })])
    const state = stateEnMemoria()
    const svc = crearServicio(monday, state)

    const r = await svc.escaneoOportunidades()
    expect(r.ventasCreadas).toEqual([{ oportunidadId: '11', nombre: 'Cliente 11', ventaItemId: 'vta-1' }])
    expect(monday.ventas[0]).toMatchObject({ clienteNombre: 'Cliente 11', unidadCodigo: 'U-101', valorVenta: 2500000 })
    expect(state.mapa.get('venta-creada:11')).toBe('vta-1')
  })

  it('dedup: la segunda pasada no duplica apartados ni ventas', async () => {
    const monday = mondayMock([], [oportunidad('10', { etapa: 'Aparto' }), oportunidad('11', { etapa: 'Ganado' })])
    const state = stateEnMemoria()
    const svc = crearServicio(monday, state)

    await svc.escaneoOportunidades()
    const r2 = await svc.escaneoOportunidades()
    expect(r2.apartadosCreados).toEqual([])
    expect(r2.ventasCreadas).toEqual([])
    expect(monday.apartados).toHaveLength(1)
    expect(monday.ventas).toHaveLength(1)
    expect(state.mapa.get('contador:apartadosCreados')).toBe('1')
    expect(state.mapa.get('contador:ventasCreadas')).toBe('1')
  })

  it('ignora oportunidades en otras etapas', async () => {
    const monday = mondayMock([], [
      oportunidad('10', { etapa: 'Cotizador' }),
      oportunidad('11', { etapa: 'Perdido' }),
      oportunidad('12', { etapa: 'Afluencia' }),
    ])
    const svc = crearServicio(monday, stateEnMemoria())
    const r = await svc.escaneoOportunidades()
    expect(r.apartadosCreados).toEqual([])
    expect(r.ventasCreadas).toEqual([])
    expect(monday.apartados).toEqual([])
    expect(monday.ventas).toEqual([])
  })

  it('un fallo de Monday en una oportunidad no detiene a las demás', async () => {
    const monday = mondayMock([], [oportunidad('10', { etapa: 'Aparto' }), oportunidad('11', { etapa: 'Ganado' })])
    vi.spyOn(monday, 'crearApartado').mockRejectedValueOnce(new Error('Monday caído'))
    const state = stateEnMemoria()
    const svc = crearServicio(monday, state)

    const r = await svc.escaneoOportunidades()
    expect(r.errores).toHaveLength(1)
    expect(r.errores[0]?.oportunidadId).toBe('10')
    expect(r.ventasCreadas).toHaveLength(1) // la segunda oportunidad sí se procesó
    expect(state.mapa.get('apartado-creado:10')).toBeUndefined() // sin dedup: se reintenta en la próxima pasada
  })
})