import { BadRequestException } from '@nestjs/common';
import { Prisma } from '@prisma/client';
import { EstadoFactura, EstadoSifen } from '../facturas/facturas.enums';
import { endOfDayAsuncion, startOfDayAsuncion } from '../utils/utilidades';

/**
 * Criterio único de las comisiones de vendedores y cobradores (spec 2026-10-17-comercial-finanzas):
 * - moneda de una comisión: `factura_cab.moneda_id`, si no `recibos_cobro.moneda_id`, si no la base
 *   de la empresa (`empresa_monedas.es_principal`);
 * - fecha del documento: `factura_cab.dfeemide`, si no `recibos_cobro.fecha_emision`.
 * Lo usan el resumen, el detalle, los PDF, las liquidaciones y (Task 4) las comisiones de supervisor.
 */

export type MonedaApi = { id: string; codigo: string; simbolo: string };

export const SELECT_MONEDA = { id: true, codigo: true, simbolo: true } as const;

type MonedaFila = { id: string; codigo: string | null; simbolo: string | null } | null | undefined;

export type ComisionConDocumento = {
  factura_cab?: { moneda?: MonedaFila; dfeemide?: Date | null } | null;
  recibos_cobro?: { moneda?: MonedaFila; fecha_emision?: Date | null } | null;
  /** Respaldo de fecha de una comisión RECIBO_MULTI cuyo recibo no se encuentra. */
  created_at?: Date | null;
};

/** Include de Prisma con lo que necesitan `monedaDeComision` y `fechaDocumentoDeComision`. */
export const INCLUDE_DOCUMENTO_MONEDA = {
  factura_cab: { select: { moneda_id: true, dfeemide: true, moneda: { select: SELECT_MONEDA } } },
  recibos_cobro: { select: { moneda_id: true, fecha_emision: true, moneda: { select: SELECT_MONEDA } } },
} as const;

export function aMonedaApi(m: MonedaFila): MonedaApi | null {
  if (!m) return null;
  return { id: m.id, codigo: m.codigo ?? '', simbolo: m.simbolo ?? '' };
}

/** Moneda de la comisión: la del documento (factura, si no recibo); si no hay, la base. */
export function monedaDeComision(c: ComisionConDocumento, base: MonedaApi | null): MonedaApi | null {
  return aMonedaApi(c.factura_cab?.moneda) ?? aMonedaApi(c.recibos_cobro?.moneda) ?? base;
}

/** Fecha del documento de la comisión (factura, si no recibo). */
export function fechaDocumentoDeComision(c: ComisionConDocumento): Date | null {
  return c.factura_cab?.dfeemide ?? c.recibos_cobro?.fecha_emision ?? (sinDocumento(c) ? (c.created_at ?? null) : null);
}

/** Sin factura ni recibo: solo pasa con una RECIBO_MULTI cuyo recibo no se resolvió. */
function sinDocumento(c: ComisionConDocumento): boolean {
  return !c.factura_cab && !c.recibos_cobro;
}

/**
 * Fecha del documento como ISO con los dígitos de la hora de Asunción, para que
 * `fmtFechaCalendario` muestre el día correcto:
 * - `dfeemide` es `timestamp` sin zona y ya guarda los dígitos de Asunción → tal cual;
 * - `fecha_emision` del recibo es `timestamptz` (instante real) → se pasa al reloj de Asunción.
 */
export function fechaDocumentoIso(c: ComisionConDocumento): string | null {
  if (c.factura_cab?.dfeemide) return c.factura_cab.dfeemide.toISOString();
  // fecha_emision (timestamptz) y created_at (timestamp con dígitos UTC) son instantes reales.
  const f = c.recibos_cobro?.fecha_emision ?? (sinDocumento(c) ? c.created_at : null);
  if (!f) return null;
  const p: Record<string, string> = {};
  for (const x of new Intl.DateTimeFormat('en-CA', {
    timeZone: 'America/Asuncion',
    year: 'numeric',
    month: '2-digit',
    day: '2-digit',
    hour: '2-digit',
    minute: '2-digit',
    second: '2-digit',
    hour12: false,
  }).formatToParts(f))
    p[x.type] = x.value;
  const hora = p.hour === '24' ? '00' : p.hour;
  const ms = String(f.getUTCMilliseconds()).padStart(3, '0');
  return `${p.year}-${p.month}-${p.day}T${hora}:${p.minute}:${p.second}.${ms}Z`;
}

type PrismaLike = {
  empresa_monedas: { findFirst: (args: any) => Promise<any> };
  moneda: { findFirst: (args: any) => Promise<any> };
};

/** Moneda base de la empresa: la principal de `empresa_monedas`; si no tiene, PYG (igual que la migración). */
export async function monedaBaseEmpresa(prisma: PrismaLike, empresaId: string): Promise<MonedaApi | null> {
  const principal = await prisma.empresa_monedas.findFirst({
    where: { empresa_id: empresaId, es_principal: true },
    // Mismo desempate que la migración 20261017_comercial_moneda.
    orderBy: [{ active: { sort: 'desc', nulls: 'last' } }, { created_at: { sort: 'asc', nulls: 'last' } }],
    select: { moneda: { select: SELECT_MONEDA } },
  });
  if (principal?.moneda) return aMonedaApi(principal.moneda);
  return aMonedaApi(await prisma.moneda.findFirst({ where: { codigo: 'PYG' }, select: SELECT_MONEDA }));
}

/** Moneda por id para un filtro `moneda_id`. 400 si no existe (antes caía en un rótulo vacío o "PYG"). */
export async function monedaPorId(
  prisma: { moneda: { findUnique: (args: any) => Promise<any> } },
  monedaId: string,
): Promise<MonedaApi> {
  const m = aMonedaApi(await prisma.moneda.findUnique({ where: { id: monedaId }, select: SELECT_MONEDA }));
  if (!m) throw new BadRequestException('La moneda no existe');
  return m;
}

/** Normaliza 'YYYY-MM-DD' (o un ISO que empiece así). 400 si no es una fecha. */
export function parseYmd(valor: string | undefined | null, campo = 'fecha'): string | undefined {
  if (!valor) return undefined;
  const ymd = String(valor).slice(0, 10);
  if (!/^\d{4}-\d{2}-\d{2}$/.test(ymd) || isNaN(new Date(`${ymd}T00:00:00Z`).getTime())) {
    throw new BadRequestException(`La ${campo} no es válida (formato AAAA-MM-DD)`);
  }
  return ymd;
}

/**
 * Where de Prisma: la comisión pertenece al período por la fecha de su documento.
 * Excluye documentos anulados (factura anulada o cancelada en SIFEN, recibo anulado).
 * `desde` y `hasta` son días calendario de Asunción ('YYYY-MM-DD'), los dos inclusive.
 */
export function whereFechaDocumento(desde?: string, hasta?: string): Prisma.comisionesWhereInput {
  // dfeemide: `timestamp` sin zona con los dígitos de Asunción → límites "naive" en UTC.
  const rangoFactura =
    desde || hasta
      ? {
          dfeemide: {
            ...(desde ? { gte: new Date(`${desde}T00:00:00.000Z`) } : {}),
            ...(hasta ? { lte: new Date(`${hasta}T23:59:59.999Z`) } : {}),
          },
        }
      : {};
  // fecha_emision: `timestamptz` → límites del día en Asunción.
  const rangoRecibo =
    desde || hasta
      ? {
          fecha_emision: {
            ...(desde ? { gte: startOfDayAsuncion(desde) } : {}),
            ...(hasta ? { lte: endOfDayAsuncion(hasta) } : {}),
          },
        }
      : {};
  return {
    OR: [
      {
        factura_id: { not: null },
        factura_cab: {
          // 'Anulada' por registros legacy previos al enum 'Anulado'. 'Rechazado' en SIFEN puede ser
          // transitorio, así que solo se excluye 'Cancelado'.
          estado: { notIn: [EstadoFactura.ANULADA, 'Anulada'] },
          OR: [{ estado_sifen: null }, { estado_sifen: { not: EstadoSifen.CANCELADO } }],
          ...rangoFactura,
        },
      },
      {
        factura_id: null,
        recibos_cobro: { estado: { not: 'anulado' }, ...rangoRecibo },
      },
      // RECIBO_MULTI: sin relación en la base. El período se filtra después, en `resolverRecibosMulti`.
      WHERE_RECIBO_MULTI,
    ],
  };
}

/**
 * Comisiones de cobranza que crea el recibo multi-factura (`recibos.service.ts`, "Comisión de cobrador"):
 * no llevan `factura_id` ni `recibo_id`; el recibo (`recibos_cobro.id`) va en `observaciones`.
 */
export const PREFIJO_RECIBO_MULTI = 'RECIBO_MULTI:';
export const WHERE_RECIBO_MULTI: Prisma.comisionesWhereInput = {
  factura_id: null,
  recibo_id: null,
  observaciones: { startsWith: PREFIJO_RECIBO_MULTI },
};

const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;

/** `true` si `v` es un uuid (los ids de persona y de factura que llegan en el body). */
export function esUuid(v: unknown): v is string {
  return typeof v === 'string' && UUID.test(v);
}

type ComisionResoluble = {
  factura_id?: string | null;
  recibo_id?: string | null;
  observaciones?: string | null;
  created_at?: Date | null;
  recibos_cobro?: unknown;
};

/** Id del recibo de una comisión RECIBO_MULTI; `null` si no es una (o el id no es válido). */
export function reciboMultiId(c: ComisionResoluble): string | null {
  if (c.factura_id || c.recibo_id || !c.observaciones?.startsWith(PREFIJO_RECIBO_MULTI)) return null;
  const id = c.observaciones.slice(PREFIJO_RECIBO_MULTI.length).trim();
  return UUID.test(id) ? id : '';
}

/**
 * Completa las comisiones RECIBO_MULTI con su recibo (`recibos_cobro`: fecha_emision, moneda, número y
 * cliente) y aplica el período. Sin recibo encontrado quedan con `recibos_cobro: null`: su fecha pasa a
 * `created_at` y su moneda a la base. Las de recibo anulado se descartan (como la rama de recibo del where).
 * Las demás comisiones pasan sin cambios.
 */
export async function resolverRecibosMulti<T extends ComisionResoluble>(
  prisma: { recibos_cobro: { findMany: (args: any) => Promise<any[]> } },
  comisiones: T[],
  desde?: string,
  hasta?: string,
): Promise<T[]> {
  const ids = [...new Set(comisiones.map(reciboMultiId).filter((id): id is string => !!id))];
  const recibos = ids.length
    ? await prisma.recibos_cobro.findMany({
        where: { id: { in: ids } },
        select: {
          id: true,
          numero_recibo: true,
          fecha_emision: true,
          estado: true,
          moneda_id: true,
          moneda: { select: SELECT_MONEDA },
          clientes: {
            select: {
              id: true,
              nombre_fantasia: true,
              personas: { select: { razon_social: true, ruc: true, nro_documento: true } },
            },
          },
        },
      })
    : [];
  const porId = new Map(recibos.map((r) => [r.id, r]));
  const gte = desde ? startOfDayAsuncion(desde).getTime() : -Infinity;
  const lte = hasta ? endOfDayAsuncion(hasta).getTime() : Infinity;

  const salida: T[] = [];
  for (const c of comisiones) {
    const id = reciboMultiId(c);
    if (id === null) {
      salida.push(c);
      continue;
    }
    const recibo = id ? porId.get(id) : undefined;
    if (recibo?.estado === 'anulado') continue;
    const fecha: Date | null | undefined = recibo ? recibo.fecha_emision : c.created_at;
    if ((desde || hasta) && (!fecha || fecha.getTime() < gte || fecha.getTime() > lte)) continue;
    salida.push({ ...c, recibos_cobro: recibo ?? null });
  }
  return salida;
}

export type EstadoFiltroComision = 'todas' | 'pendiente' | 'liquidada';

/** Estados de la tabla `comisiones` que cuentan como pendientes de liquidar en los totales. */
export const ESTADOS_PENDIENTES = ['pendiente', 'aprobada'];

/** Filtro por estado del resumen y el detalle (`estado=todas|pendiente|liquidada`). */
export function whereEstadoComision(estado?: string): Prisma.comisionesWhereInput {
  if (estado === 'pendiente') return { estado: { in: ESTADOS_PENDIENTES } };
  if (estado === 'liquidada') return { estado: 'liquidada' };
  if (estado && estado !== 'todas') throw new BadRequestException('El estado debe ser todas, pendiente o liquidada');
  return { estado: { notIn: ['cancelada', 'anulada'] } };
}
