import { Prisma } from '@prisma/client';
import { conflicto, solicitudInvalida } from 'src/common/utils/error-estructurado';
import { normalizarMoneda } from 'src/common/utils/moneda-cuenta.util';
import { bloquearRequisicion } from 'src/ordenes-compra/bloqueos-oc';
import { estadoLinea, estadoPorEjecucion, MONEDA_PRECIOS_REQUISICION, montoEnMonedaRequisicion } from './reglas-requisicion';

type Tx = Prisma.TransactionClient;

/**
 * Ejecución de una requisición desde Facturas y Gastos (una sola definición para los dos).
 * - `items`: las líneas del documento; `subtotal` en la moneda del documento.
 * - `monedaCodigo` y `cotizacion`: los del documento. Lo ejecutado se suma en la moneda de la requisición
 *   (`montoEnMonedaRequisicion`, ítem por ítem, igual que la migración `20261029100300`).
 * - `fechaOperacion`: la del documento, para el período del presupuesto.
 */
export interface ParamsEjecucion {
  empresaId: string;
  requisicionId: string | null;
  items: Array<{ requisicion_det_id: string | null; cantidad: number; subtotal: number }>;
  monedaCodigo: string;
  cotizacion: number;
  fechaOperacion: Date;
}

/** Estados en los que un documento puede ejecutar la requisición (se re-chequea bajo `req:`). */
const ESTADOS_EJECUTABLES = ['aprobada', 'ejecutada_parcial'];
/** Estados cuya cabecera se recalcula con lo ejecutado (no toca canceladas ni rechazadas). */
const ESTADOS_CON_EJECUCION = ['aprobada', 'ejecutada_parcial', 'ejecutada_total'];

const num = (v: unknown): number => Number(v ?? 0) || 0;
/** Mitad lejos de cero, simétrico con negativos (como `redondear2` de las reglas y ROUND de Postgres). */
const redondear = (n: number, decimales: number): number => {
  const f = 10 ** decimales;
  const r = Math.round((Math.abs(n) + Number.EPSILON) * f) / f;
  return n < 0 ? -r : r;
};

interface ResumenLinea {
  cantidad: number;
  monto: number;
  /** Primer ítem del documento (base 1) que ejecuta la línea, para el error. */
  linea: number;
}

function resumirPorLinea(p: ParamsEjecucion): Map<string, ResumenLinea> {
  const codigo = normalizarMoneda(p.monedaCodigo);
  const resumen = new Map<string, ResumenLinea>();
  p.items.forEach((item, idx) => {
    if (!item.requisicion_det_id) return;
    const monto = montoEnMonedaRequisicion(redondear(num(item.subtotal), 2), codigo, num(p.cotizacion));
    const prev = resumen.get(item.requisicion_det_id) ?? { cantidad: 0, monto: 0, linea: idx + 1 };
    resumen.set(item.requisicion_det_id, {
      cantidad: redondear(prev.cantidad + num(item.cantidad), 4),
      monto: redondear(prev.monto + monto, 2),
      linea: prev.linea,
    });
  });
  return resumen;
}

/**
 * Verdadero si los dos juegos de ítems ejecutan lo mismo: por línea de la requisición, la misma cantidad y el mismo
 * subtotal (en la moneda del documento). Los ítems sin línea no ejecutan nada. Sirve a la edición para no revertir
 * ni volver a aplicar cuando no cambia lo ejecutado (como `cambianItems` de Gastos).
 */
export function mismaEjecucion(a: ParamsEjecucion['items'], b: ParamsEjecucion['items']): boolean {
  const porLinea = (items: ParamsEjecucion['items']) => {
    const m = new Map<string, { cantidad: number; subtotal: number }>();
    for (const item of items) {
      if (!item.requisicion_det_id) continue;
      const prev = m.get(item.requisicion_det_id) ?? { cantidad: 0, subtotal: 0 };
      m.set(item.requisicion_det_id, {
        cantidad: redondear(prev.cantidad + num(item.cantidad), 4),
        subtotal: redondear(prev.subtotal + num(item.subtotal), 2),
      });
    }
    return m;
  };
  const ma = porLinea(a);
  const mb = porLinea(b);
  if (ma.size !== mb.size) return false;
  for (const [id, x] of ma) {
    const y = mb.get(id);
    if (!y || y.cantidad !== x.cantidad || y.subtotal !== x.subtotal) return false;
  }
  return true;
}

/**
 * Moneda y cotización de un documento para `ParamsEjecucion`. Sin requisición no consulta nada; moneda null es la
 * moneda local (los documentos viejos).
 */
export async function monedaDelDocumento(
  tx: Tx,
  requisicionId: string | null | undefined,
  monedaId: string | null | undefined,
  cotizacion: unknown,
): Promise<{ monedaCodigo: string; cotizacion: number }> {
  if (!requisicionId || !monedaId) return { monedaCodigo: MONEDA_PRECIOS_REQUISICION, cotizacion: 1 };
  const moneda = await tx.moneda.findUnique({ where: { id: monedaId }, select: { codigo: true } });
  return { monedaCodigo: normalizarMoneda(moneda?.codigo), cotizacion: num(cotizacion) || 1 };
}

/**
 * Suma lo ejecutado por el documento a las líneas de la requisición.
 * Toma `req:` y relee la requisición y sus líneas bajo el lock: dos documentos a la vez sobre la misma línea suman
 * uno sobre el otro o el segundo recibe `CANTIDAD_SUPERA_PENDIENTE`. La requisición tiene que seguir aprobada o
 * ejecutada parcial (si no, 409 `REQUISICION_ESTADO_CAMBIADO`). Ejecutar por encima de lo aprobado en monto no se
 * bloquea (decisión del controlador); en cantidad, no se pasa de lo solicitado.
 */
export async function aplicarEjecucionRequisicion(tx: Tx, p: ParamsEjecucion): Promise<void> {
  if (!p.requisicionId) return;
  const resumen = resumirPorLinea(p);
  if (!resumen.size) return;

  await bloquearRequisicion(tx, p.requisicionId);
  const requisicion = await tx.requisicion_cab.findFirst({
    where: { id: p.requisicionId, empresa_id: p.empresaId, activo: true },
    include: { requisicion_det: true },
  });
  if (!requisicion) {
    throw solicitudInvalida({
      message: 'No se encontró la requisición vinculada al documento',
      codigo: 'REQUISICION_NO_ENCONTRADA',
      campo: 'requisicion_id',
    });
  }
  if (!ESTADOS_EJECUTABLES.includes(String(requisicion.estado))) {
    throw conflicto({
      message: 'La requisición cambió de estado y ya no se puede ejecutar. Recargá y revisá la requisición.',
      codigo: 'REQUISICION_ESTADO_CAMBIADO',
      estado_actual: requisicion.estado,
    });
  }

  const lineas = new Map(requisicion.requisicion_det.map((d) => [d.id, d]));
  for (const [detId, r] of resumen) {
    const det = lineas.get(detId);
    if (!det) {
      throw solicitudInvalida({
        message: `La línea ${r.linea} no pertenece a la requisición vinculada`,
        codigo: 'LINEA_FUERA_DE_REQUISICION',
        campo: 'requisicion_det_id',
        linea: r.linea,
      });
    }
    const solicitada = num(det.cantidad_solicitada);
    const ejecutada = redondear(num(det.cantidad_ejecutada) + r.cantidad, 4);
    if (ejecutada - solicitada > 0.00005) {
      throw solicitudInvalida({
        message: `La línea ${r.linea} supera lo pendiente de la requisición (${redondear(solicitada - num(det.cantidad_ejecutada), 4)})`,
        codigo: 'CANTIDAD_SUPERA_PENDIENTE',
        campo: 'requisicion_det_id',
        linea: r.linea,
      });
    }
  }

  const nuevas = await escribirLineas(tx, resumen, lineas, +1);
  await ajustarPresupuestoEjecutadoRequisicion(tx, requisicion, p.fechaOperacion, nuevas.porCentro, 'increment');
  await recalcularEstadoRequisicion(tx, requisicion, nuevas.lineas);
}

/**
 * Resta lo que el documento había ejecutado (anular o editar). Toma `req:` y relee; no mira el estado: anular un
 * documento de una requisición cancelada también devuelve lo pendiente de sus líneas. Con la misma moneda y
 * cotización que al aplicar, deja la línea exactamente como estaba (la conversión es ítem por ítem en los dos).
 */
export async function revertirEjecucionRequisicion(tx: Tx, p: ParamsEjecucion): Promise<void> {
  if (!p.requisicionId) return;
  const resumen = resumirPorLinea(p);
  if (!resumen.size) return;

  await bloquearRequisicion(tx, p.requisicionId);
  const requisicion = await tx.requisicion_cab.findFirst({
    where: { id: p.requisicionId, empresa_id: p.empresaId, activo: true },
    include: { requisicion_det: true },
  });
  if (!requisicion) return;

  const lineas = new Map(requisicion.requisicion_det.map((d) => [d.id, d]));
  const nuevas = await escribirLineas(tx, resumen, lineas, -1);
  await ajustarPresupuestoEjecutadoRequisicion(tx, requisicion, p.fechaOperacion, nuevas.porCentro, 'decrement');
  await recalcularEstadoRequisicion(tx, requisicion, nuevas.lineas);
}

/** Moneda y cotización de un documento, antes y después de editarlo. */
export interface MonedaEjecucion {
  monedaCodigo: string;
  cotizacion: number;
}

export interface ParamsRevaluacion {
  empresaId: string;
  requisicionId: string | null;
  items: ParamsEjecucion['items'];
  antes: MonedaEjecucion;
  despues: MonedaEjecucion;
  fechaOperacion: Date;
}

/**
 * Un documento ya ejecutado cambia solo su moneda o su cotización (mismas líneas, cantidades y requisición): no es
 * una ejecución nueva, así que no se revierte ni se aplica. Toma `req:`, relee y ajusta solo `monto_ejecutado` de
 * cada línea y el presupuesto por la diferencia (después − antes, ítem por ítem). No toca cantidades ni el estado de
 * la línea y no mira el estado de la requisición: corregir la cotización de un gasto de una requisición cancelada
 * sigue pudiéndose. La cabecera recalcula `total_ejecutado` siempre y el estado solo en aprobada / ejecutada parcial
 * / total.
 */
export async function revaluarEjecucionRequisicion(tx: Tx, p: ParamsRevaluacion): Promise<void> {
  if (!p.requisicionId) return;
  const base = { empresaId: p.empresaId, requisicionId: p.requisicionId, items: p.items, fechaOperacion: p.fechaOperacion };
  const antes = resumirPorLinea({ ...base, ...p.antes });
  const despues = resumirPorLinea({ ...base, ...p.despues });
  if (!despues.size) return;

  await bloquearRequisicion(tx, p.requisicionId);
  const requisicion = await tx.requisicion_cab.findFirst({
    where: { id: p.requisicionId, empresa_id: p.empresaId, activo: true },
    include: { requisicion_det: true },
  });
  if (!requisicion) return;

  const lineas = new Map(requisicion.requisicion_det.map((d) => [d.id, d]));
  const escritas = new Map<string, { cantidad_ejecutada: number; monto_ejecutado: number }>();
  const suben = new Map<string, number>();
  const bajan = new Map<string, number>();
  for (const [detId, r] of despues) {
    const det = lineas.get(detId);
    if (!det) continue;
    const diferencia = redondear(r.monto - (antes.get(detId)?.monto ?? 0), 2);
    if (diferencia === 0) continue;
    const monto = Math.max(0, redondear(num(det.monto_ejecutado) + diferencia, 2));
    await tx.requisicion_det.update({ where: { id: detId }, data: { monto_ejecutado: monto, updated_at: new Date() } });
    escritas.set(detId, { cantidad_ejecutada: num(det.cantidad_ejecutada), monto_ejecutado: monto });
    if (det.centro_costo_id) {
      const centro = String(det.centro_costo_id);
      const destino = diferencia > 0 ? suben : bajan;
      destino.set(centro, redondear((destino.get(centro) ?? 0) + Math.abs(diferencia), 2));
    }
  }
  if (!escritas.size) return;
  await ajustarPresupuestoEjecutadoRequisicion(tx, requisicion, p.fechaOperacion, suben, 'increment');
  await ajustarPresupuestoEjecutadoRequisicion(tx, requisicion, p.fechaOperacion, bajan, 'decrement');
  await recalcularEstadoRequisicion(tx, requisicion, escritas);
}

type LineaReq = { id: string; cantidad_solicitada: unknown; cantidad_ejecutada: unknown; monto_ejecutado: unknown; centro_costo_id: string | null };

async function escribirLineas(
  tx: Tx,
  resumen: Map<string, ResumenLinea>,
  lineas: Map<string, LineaReq>,
  signo: 1 | -1,
): Promise<{ lineas: Map<string, { cantidad_ejecutada: number; monto_ejecutado: number }>; porCentro: Map<string, number> }> {
  const escritas = new Map<string, { cantidad_ejecutada: number; monto_ejecutado: number }>();
  const porCentro = new Map<string, number>();
  for (const [detId, r] of resumen) {
    const det = lineas.get(detId);
    if (!det) continue;
    const cantidad = Math.max(0, redondear(num(det.cantidad_ejecutada) + signo * r.cantidad, 4));
    const monto = Math.max(0, redondear(num(det.monto_ejecutado) + signo * r.monto, 2));
    await tx.requisicion_det.update({
      where: { id: detId },
      data: {
        cantidad_ejecutada: cantidad,
        monto_ejecutado: monto,
        estado: estadoLinea(num(det.cantidad_solicitada), cantidad),
        updated_at: new Date(),
      },
    });
    escritas.set(detId, { cantidad_ejecutada: cantidad, monto_ejecutado: monto });
    if (det.centro_costo_id) {
      const centro = String(det.centro_costo_id);
      porCentro.set(centro, redondear((porCentro.get(centro) ?? 0) + r.monto, 2));
    }
  }
  return { lineas: escritas, porCentro };
}

/**
 * `total_ejecutado` (Σ `monto_ejecutado`, en la moneda de la requisición) siempre, para que el listado coincida con
 * las líneas (también al anular un documento de una requisición cancelada). El estado de la cabecera por sus líneas,
 * solo en aprobada / ejecutada parcial / ejecutada total, como la migración: no cambia canceladas ni rechazadas.
 * Usa las líneas leídas bajo el lock con los valores recién escritos (no vuelve a leer).
 */
async function recalcularEstadoRequisicion(
  tx: Tx,
  requisicion: { id: string; estado: string; requisicion_det: LineaReq[] },
  escritas: Map<string, { cantidad_ejecutada: number; monto_ejecutado: number }>,
): Promise<void> {
  const lineas = requisicion.requisicion_det.map((d) => {
    const w = escritas.get(d.id);
    return {
      cantidad_solicitada: num(d.cantidad_solicitada),
      cantidad_ejecutada: w ? w.cantidad_ejecutada : num(d.cantidad_ejecutada),
      monto_ejecutado: w ? w.monto_ejecutado : num(d.monto_ejecutado),
    };
  });
  const total = redondear(
    lineas.reduce((acc, l) => acc + l.monto_ejecutado, 0),
    2,
  );
  const conEjecucion = ESTADOS_CON_EJECUCION.includes(String(requisicion.estado));
  await tx.requisicion_cab.update({
    where: { id: requisicion.id },
    data: {
      total_ejecutado: total,
      ...(conEjecucion ? { estado: estadoPorEjecucion(lineas) } : {}),
      updated_at: new Date(),
    },
  });
}

/**
 * Presupuesto del centro de costo de cada línea, en el período de la fecha del documento y del origen de la
 * requisición (compra o gasto). Sin período o sin presupuesto no hace nada. Los montos van en guaraníes.
 */
async function ajustarPresupuestoEjecutadoRequisicion(
  tx: Tx,
  requisicion: { empresa_id: string; origen_tipo: string },
  fechaOperacion: Date,
  porCentro: Map<string, number>,
  op: 'increment' | 'decrement',
): Promise<void> {
  if (!porCentro.size) return;
  const periodo = await tx.cont_periodos.findFirst({
    where: { empresa_id: requisicion.empresa_id, fecha_inicio: { lte: fechaOperacion }, fecha_fin: { gte: fechaOperacion } },
    select: { id: true },
    orderBy: [{ anio: 'desc' }, { mes: 'desc' }],
  });
  if (!periodo) return;

  for (const [centroCostoId, monto] of porCentro) {
    if (monto <= 0) continue;
    const presupuesto = await tx.requisicion_presupuesto.findFirst({
      where: {
        empresa_id: requisicion.empresa_id,
        periodo_id: periodo.id,
        centro_costo_id: centroCostoId,
        origen_tipo: String(requisicion.origen_tipo),
        activo: true,
      },
      select: { id: true, monto_ejecutado: true },
    });
    if (!presupuesto) continue;
    const data =
      op === 'increment'
        ? { monto_ejecutado: { increment: monto }, updated_at: new Date() }
        : { monto_ejecutado: Math.max(0, redondear(num(presupuesto.monto_ejecutado) - monto, 2)), updated_at: new Date() };
    await tx.requisicion_presupuesto.update({ where: { id: presupuesto.id }, data });
  }
}
