FRASA-CAS/api-gateway/src/controllers/webhooks.controller.ts

import type { Request, Response } from 'express'
import { z } from 'zod'
import { config } from '../config/index.js'
import { automatizacionesService } from '../services/automatizaciones.service.js'

const eventoSchema = z
  .object({
    type: z.string(),
    boardId: z.union([z.string(), z.number()]),
    // Monday manda pulseId en los eventos reales (create_pulse) y itemId en
    // las pruebas del panel de webhooks; se aceptan ambos.
    itemId: z.union([z.string(), z.number()]).optional(),
    pulseId: z.union([z.string(), z.number()]).optional(),
  })
  .passthrough()

const payloadSchema = z.object({ event: eventoSchema }).passthrough()

/**
 * POST /api/webhooks/monday
 * Handshake: Monday envía { challenge } al registrar el webhook y exige que
 * se responda tal cual. Eventos reales: se responde 200 de inmediato y se
 * procesan en segundo plano.
 *
 * OJO: Monday NO firma sus webhooks → el payload no es confiable. Por eso el
 * evento solo se usa como DISPARADOR: el round-robin re-consulta el tablero
 * vía API antes de escribir nada.
 */
export function webhookMonday(req: Request, res: Response): void {
  const body = req.body as Record<string, unknown>

  if (typeof body?.['challenge'] === 'string') {
    res.json({ challenge: body['challenge'] })
    return
  }

  const parsed = payloadSchema.safeParse(body)
  if (!parsed.success) {
    // eslint-disable-next-line no-console
    console.log('[webhook monday] payload sin estructura de evento reconocida; se ignora')
    res.sendStatus(200)
    return
  }

  const { type, boardId, itemId, pulseId } = parsed.data.event
  const esBoardLeads = String(boardId) === config.monday.boards.leads
  const esBoardOportunidades = String(boardId) === config.monday.boards.oportunidades
  const idEvento = itemId ?? pulseId

  // eslint-disable-next-line no-console
  console.log(`[webhook monday] tipo=${type} board=${boardId} item=${idEvento ?? '?'}`)

  // Monday registra el webhook como 'create_item' pero el payload real llega
  // como 'create_pulse'; se aceptan ambos.
  if ((type === 'create_item' || type === 'create_pulse') && esBoardLeads && idEvento !== undefined) {
    const id = String(idEvento)
    // Fire-and-forget: la respuesta 200 no espera a que termine la asignación
    void automatizacionesService
      .runRoundRobin(id)
      .then((r) => {
        // eslint-disable-next-line no-console
        console.log(`[webhook monday] round-robin item=${id}: ${r.asignados} asignado(s)`)
      })
      .catch((err: unknown) => {
        // eslint-disable-next-line no-console
        console.error(`[webhook monday] error en round-robin item=${id}:`, err)
      })
  }

  // Cambio de etapa en Oportunidades → crear Apartado/Venta si aplica.
  // El payload de Monday no es confiable (no va firmado), así que solo se usa
  // como disparador: el escaneo re-consulta el tablero y es idempotente (dedup
  // en AutomatizacionState). El cron de polling queda como red de seguridad.
  // OJO: el webhook se registra como 'change_column_value' pero el payload
  // real llega como 'update_column_value'; se aceptan los tres nombres.
  if (
    (type === 'change_status_column_value' ||
      type === 'change_column_value' ||
      type === 'update_column_value') &&
    esBoardOportunidades
  ) {
    void automatizacionesService
      .escaneoOportunidades()
      .then((r) => {
        // eslint-disable-next-line no-console
        console.log(
          `[webhook monday] oportunidades: ${r.apartadosCreados.length} apartado(s), ` +
            `${r.ventasCreadas.length} venta(s), ${r.errores.length} error(es)`,
        )
      })
      .catch((err: unknown) => {
        // eslint-disable-next-line no-console
        console.error('[webhook monday] error en escaneo de oportunidades:', err)
      })
  }

  res.sendStatus(200)
}