import { Prisma } from '@prisma/client';
import { solicitudInvalida } from 'src/common/utils/error-estructurado';
import { esMedioSinCaja } from 'src/common/utils/medio-pago-sin-caja.util';
import { TipoMedioPago, tipoMedioPago } from 'src/common/utils/tipo-medio-pago.util';
import { OrdenPagoProveedorDetalleDto } from './dto/create-orden-pago-proveedor.dto';

// ─────────────────────────── Estados de la orden de pago ───────────────────────────

export const ESTADOS_OP = ['borrador', 'pendiente_aprobacion', 'rechazada', 'aprobada', 'pagada', 'anulada'] as const;
export type EstadoOp = (typeof ESTADOS_OP)[number];

/** Valores de `orden_pago_proveedor_cab.estado` de cada clave (sin `borrador`, que es el resto; ver abajo). */
const ESTADO_ANULADA = 'ANULADA';
const VALORES_OP: Record<Exclude<EstadoOp, 'borrador' | 'anulada'>, string[]> = {
  pendiente_aprobacion: ['PENDIENTE_APROBACION'],
  rechazada: ['RECHAZADA'],
  aprobada: ['PENDIENTE'],
  pagada: ['PAGADO', 'APLICADO', 'aplicado'],
};
const NO_BORRADOR = [ESTADO_ANULADA, ...Object.values(VALORES_OP).flat()];
/** Valores de la base de una OP pagada (para el SQL de `idsSinTesoreria`, con el mismo criterio que `whereEstadoOp`). */
export const VALORES_OP_PAGADA: readonly string[] = VALORES_OP.pagada;

/**
 * Clave del estado de una OP (la única que viaja en el filtro y en `estado_clave`):
 * - `anulada`: `anulado = true` o `ANULADA`;
 * - `pagada`: `PAGADO`, `APLICADO` o `aplicado`;
 * - `aprobada`: `PENDIENTE` en mayúscula;
 * - `pendiente_aprobacion` y `rechazada`: su valor;
 * - `borrador`: el resto (`BORRADOR`, el legacy `pendiente` en minúscula, NULL).
 * Comparación exacta (como Postgres), igual que `whereEstadoOp`.
 */
export function estadoOpClave(c: { estado?: string | null; anulado?: boolean | null }): EstadoOp {
  const estado = c.estado ?? null;
  if (c.anulado === true || estado === ESTADO_ANULADA) return 'anulada';
  for (const [clave, valores] of Object.entries(VALORES_OP) as Array<[EstadoOp, string[]]>) {
    if (estado != null && valores.includes(estado)) return clave;
  }
  return 'borrador';
}

/** No anulada, NULL incluidos: en Prisma `{ not: x }` excluye las filas con la columna en NULL. */
const OP_NO_ANULADA: Prisma.orden_pago_proveedor_cabWhereInput[] = [
  { OR: [{ anulado: null }, { anulado: false }] },
  { OR: [{ estado: null }, { estado: { not: ESTADO_ANULADA } }] },
];

/** Filtro de listado por clave, con el mismo criterio que `estadoOpClave` (cada OP cae en una sola clave). */
export function whereEstadoOp(clave: EstadoOp): Prisma.orden_pago_proveedor_cabWhereInput {
  if (clave === 'anulada') return { OR: [{ anulado: true }, { estado: ESTADO_ANULADA }] };
  if (clave === 'borrador') {
    return { AND: [...OP_NO_ANULADA, { OR: [{ estado: null }, { estado: { notIn: NO_BORRADOR } }] }] };
  }
  const valores = VALORES_OP[clave];
  return { AND: [...OP_NO_ANULADA, valores.length === 1 ? { estado: valores[0] } : { estado: { in: valores } }] };
}

// ─────────────────────────── Aprobación ───────────────────────────

type ConfigAprobacion = {
  requiere_aprobacion?: boolean | null;
  usar_workflow?: boolean | null;
  workflow_obligatorio?: boolean | null;
  permite_pago_sin_aprobacion?: boolean | null;
  aplicar_pago_al_guardar?: boolean | null;
};

/** `workflow_obligatorio || ((requiere_aprobacion || usar_workflow) && !permite_pago_sin_aprobacion)`. */
export function requiereAprobacionOrdenPago(c: ConfigAprobacion): boolean {
  return Boolean(
    c.workflow_obligatorio || ((c.requiere_aprobacion || c.usar_workflow) && !c.permite_pago_sin_aprobacion),
  );
}

/** «Aplica al guardar»: guardar la orden la paga. Con aprobación nunca (`aplicar_pago_al_guardar` no se tiene en cuenta). */
export function aplicaPagoAlGuardar(c: ConfigAprobacion): boolean {
  return Boolean(c.aplicar_pago_al_guardar) && !requiereAprobacionOrdenPago(c);
}

// ─────────────────────────── Estado de la cuota (CxP) ───────────────────────────

export const ESTADOS_CUOTA = ['pendiente', 'parcial', 'vencida', 'pagada', 'anulada'] as const;
export type EstadoCuota = (typeof ESTADOS_CUOTA)[number];
export const FILTRO_CON_SALDO = 'con_saldo';
export type FiltroEstadoCuota = EstadoCuota | typeof FILTRO_CON_SALDO;

const CUOTA_ANULADA = 'anulada';
type Monto = Prisma.Decimal | number | string | null | undefined;
/** NULL cuenta como 0: una cuota con `saldo_pendiente` NULL es `pagada` (igual en `whereEstadoCuota`). */
const num = (v: Monto) => (v == null ? 0 : Number(String(v)));

/**
 * Estado de una cuota, en este orden: `anulada` (`estado = 'anulada'` o `activo = false`) > `pagada`
 * (`saldo_pendiente <= 0`) > `vencida` (saldo y `fecha_vencimiento < hoy`) > `parcial` (`monto_pagado > 0`) >
 * `pendiente`. `hoy` es `hoyComoFechaPY()` (fecha de calendario de Paraguay, medianoche UTC), para comparar con la
 * columna DATE sin desfase de zona. Mismo criterio que `whereEstadoCuota`.
 */
export function estadoCuotaPagar(
  c: {
    estado?: string | null;
    activo?: boolean | null;
    saldo_pendiente: Monto;
    monto_pagado: Monto;
    fecha_vencimiento: Date | null;
  },
  hoy: Date,
): EstadoCuota {
  if (c.estado === CUOTA_ANULADA || c.activo === false) return 'anulada';
  if (num(c.saldo_pendiente) <= 0) return 'pagada';
  if (c.fecha_vencimiento && c.fecha_vencimiento.getTime() < hoy.getTime()) return 'vencida';
  if (num(c.monto_pagado) > 0) return 'parcial';
  return 'pendiente';
}

/** Filtro por estado de cuota (o `con_saldo`: pendiente, parcial y vencida), con el criterio de `estadoCuotaPagar`. */
export function whereEstadoCuota(clave: FiltroEstadoCuota, hoy: Date): Prisma.cuentas_pagarWhereInput {
  if (clave === 'anulada') return { OR: [{ estado: CUOTA_ANULADA }, { activo: false }] };
  const noAnulada: Prisma.cuentas_pagarWhereInput[] = [
    { OR: [{ estado: null }, { estado: { not: CUOTA_ANULADA } }] },
    { OR: [{ activo: null }, { activo: true }] },
  ];
  // `saldo_pendiente` NULL cuenta como pagada, igual que en `estadoCuotaPagar`.
  if (clave === 'pagada')
    return { AND: [...noAnulada, { OR: [{ saldo_pendiente: null }, { saldo_pendiente: { lte: 0 } }] }] };
  const conSaldo = [...noAnulada, { saldo_pendiente: { gt: 0 } }];
  if (clave === FILTRO_CON_SALDO) return { AND: conSaldo };
  if (clave === 'vencida') return { AND: [...conSaldo, { fecha_vencimiento: { lt: hoy } }] };
  const noVencida: Prisma.cuentas_pagarWhereInput = {
    OR: [{ fecha_vencimiento: null }, { fecha_vencimiento: { gte: hoy } }],
  };
  if (clave === 'parcial') return { AND: [...conSaldo, noVencida, { monto_pagado: { gt: 0 } }] };
  return { AND: [...conSaldo, noVencida, { OR: [{ monto_pagado: null }, { monto_pagado: { lte: 0 } }] }] };
}

// ─────────────────────────── Tesorería y contabilidad ───────────────────────────

const ORIGEN_AUTOMATICA = 'compra_auto';
type RegistroTesoreria = { estado: string } | null | undefined;
/** Lo que hace falta del medio para saber si mueve dinero (`esMedioSinCaja`). */
export type MedioDeLinea = { codigo?: number | null; descripcion?: string | null; no_mueve_caja?: boolean | null };

/**
 * Estado de Tesorería de una OP (misma forma que `estadoTesoreria` de Gastos):
 * - null si no aplica: automática (la registra la factura), no pagada, o todas sus líneas (al menos una) con un
 *   medio sin caja; una manual pagada sin medios conocidos es `PENDIENTE`, no null;
 * - el estado del egreso o del cheque vigente (no ANULADO);
 * - `PENDIENTE` si es manual, pagada, con algún medio que mueve dinero y sin ninguno de los dos.
 */
export function tesoreriaEstadoOp(
  op: { origen?: string | null; estado_clave: EstadoOp; medios: MedioDeLinea[] },
  movimiento: RegistroTesoreria,
  cheque: RegistroTesoreria,
): string | null {
  if (op.origen === ORIGEN_AUTOMATICA || op.estado_clave !== 'pagada') return null;
  const vigente = [movimiento, cheque].find((r) => r && r.estado !== 'ANULADO');
  if (vigente) return vigente.estado;
  if (op.medios.length > 0 && op.medios.every((m) => esMedioSinCaja(m, Boolean(m.no_mueve_caja)))) return null;
  return 'PENDIENTE';
}

export type EstadoContableOp = 'ASENTADO' | 'BORRADOR' | 'PENDIENTE';

/**
 * Estado contable de una OP: null sin módulo Contabilidad o si es automática; `ASENTADO` con el documento
 * CONFIRMADO; `BORRADOR` con el documento en borrador (aviso de mapeo); `PENDIENTE` si está pagada y no tiene
 * documento vigente (sin documento o revertido); si no, null.
 */
export function contabilidadEstadoOp(
  op: { origen?: string | null; estado_clave: EstadoOp },
  doc: { estado?: string | null } | null | undefined,
  conContabilidad: boolean,
): EstadoContableOp | null {
  if (!conContabilidad || op.origen === ORIGEN_AUTOMATICA) return null;
  if (doc?.estado === 'CONFIRMADO') return 'ASENTADO';
  if (doc?.estado === 'BORRADOR') return 'BORRADOR';
  return op.estado_clave === 'pagada' ? 'PENDIENTE' : null;
}

// ─────────────────────────── Datos del medio de pago ───────────────────────────

export const CODIGO_DATOS_MEDIO_INCOMPLETOS = 'DATOS_MEDIO_INCOMPLETOS';

type CampoMedio = keyof Pick<
  OrdenPagoProveedorDetalleDto,
  | 'numero_cheque'
  | 'banco_emisor'
  | 'titular_cheque'
  | 'fecha_emision_cheque'
  | 'cuenta_bancaria_id'
  | 'tarjeta_descripcion'
  | 'ultimos_4'
>;

const CAMPOS_POR_TIPO: Partial<Record<TipoMedioPago, CampoMedio[]>> = {
  CHEQUE: ['numero_cheque', 'banco_emisor', 'titular_cheque', 'fecha_emision_cheque', 'cuenta_bancaria_id'],
  TRANSFERENCIA: ['cuenta_bancaria_id'],
  DEPOSITO: ['cuenta_bancaria_id'],
  TARJETA: ['tarjeta_descripcion', 'ultimos_4'],
};

const ETIQUETA_CAMPO: Record<CampoMedio, string> = {
  numero_cheque: 'el número de cheque',
  banco_emisor: 'el banco emisor',
  titular_cheque: 'el titular del cheque',
  fecha_emision_cheque: 'la fecha de emisión del cheque',
  cuenta_bancaria_id: 'la cuenta de Tesorería',
  tarjeta_descripcion: 'la tarjeta',
  ultimos_4: 'los últimos 4 dígitos de la tarjeta',
};

/**
 * Valida los datos que pide el medio de la línea (`linea` empieza en 1). El tipo sale de `tipoMedioPago(medio)` y
 * «sin caja» de `esMedioSinCaja(medio, medio.no_mueve_caja)`: con un medio que no mueve dinero no se pide la cuenta.
 * Falta un dato → 400 `DATOS_MEDIO_INCOMPLETOS` con `campo` y `linea`.
 */
export function validarDatosMedio(det: OrdenPagoProveedorDetalleDto, medio: MedioDeLinea, linea: number): void {
  const sinCaja = esMedioSinCaja(medio, Boolean(medio.no_mueve_caja));
  const campos = (CAMPOS_POR_TIPO[tipoMedioPago(medio)] ?? []).filter((c) => !(sinCaja && c === 'cuenta_bancaria_id'));
  const falta = campos.find((c) => String(det[c] ?? '').trim() === '');
  if (!falta) return;
  throw solicitudInvalida({
    message: `Línea ${linea}: falta ${ETIQUETA_CAMPO[falta]} (${String(medio.descripcion ?? 'medio de pago')}).`,
    codigo: CODIGO_DATOS_MEDIO_INCOMPLETOS,
    campo: falta,
    linea,
  });
}

/** Texto de la tarjeta en `observaciones` de la línea (no hay columna propia): `Tarjeta <descripción> ****<últimos 4>`. */
export function observacionesTarjeta(descripcion: string, ultimos4: string): string {
  return `Tarjeta ${String(descripcion).trim()} ****${String(ultimos4).trim()}`;
}
