import { PrismaClient } from '@prisma/client';
import { ImportacionesCosteoService } from './services/importaciones-costeo.service';

export const CODIGO_IVA_IMPORTACION = 'IMP_IVA_IMPORTACION';
/** Embarques que todavía pueden cambiar de costo: los liberados ya movieron stock con ese costo, los cerrados ya se asentaron. */
export const ESTADOS_RECALCULABLES = ['BORRADOR', 'EN_TRANSITO', 'ARRIBADO', 'EN_DESPACHO', 'DESPACHADO'];

export type CambioCosteo = {
  empresa: string;
  numero: string;
  estado: string;
  antes: string;
  despues: string;
  /** Código del error (o `ERROR`) si el embarque falló; el resto de los embarques sigue. */
  error?: { codigo: string; mensaje: string };
  /** Motivo si se saltó: el estado ya no es BORRADOR…DESPACHADO al releerlo dentro de su transacción. */
  omitido?: string;
};

const redondear = (v: unknown) => Math.round((Number(v ?? 0) || 0) * 10000) / 10000;

function codigoDe(e: any): string {
  const cuerpo = typeof e?.getResponse === 'function' ? e.getResponse() : null;
  return String(cuerpo?.codigo ?? e?.codigo ?? 'ERROR');
}

/**
 * Recalcula el costeo de los embarques activos no liberados que tienen un componente de IVA de importación (el IVA dejó de
 * ser costo). Cada embarque va en su propia transacción, que relee el embarque y verifica que siga en BORRADOR…DESPACHADO.
 * `dry`: la transacción empieza con READ ONLY y no escribe; solo informa el antes/después. Un error en un embarque se informa
 * (campo `error`) y la corrida sigue. Devuelve los embarques con cambio (total o reparto por ítem), los omitidos y los fallidos.
 */
export async function recalcularPendientes(db: PrismaClient, opciones: { dry: boolean }): Promise<CambioCosteo[]> {
  const costeo = new ImportacionesCosteoService();
  const filtroEmbarque = {
    activo: true,
    estado: { in: ESTADOS_RECALCULABLES },
    componentes_costo: { some: { activo: true, concepto: { codigo: CODIGO_IVA_IMPORTACION } } },
  };
  const select = { id: true, empresa_id: true, numero: true, estado: true, costo_total_gs: true, empresas: { select: { razon_social: true } } };

  const procesar = async (tx: any, id: string): Promise<CambioCosteo | null> => {
    if (opciones.dry) await tx.$executeRawUnsafe('SET TRANSACTION READ ONLY');
    // Se relee dentro de la transacción: si ya no es recalculable (se liberó, se cerró, se dio de baja) no se toca.
    const e = await tx.imp_embarques.findFirst({ where: { id, ...filtroEmbarque }, select });
    if (!e) return { empresa: '', numero: id, estado: '', antes: '', despues: '', omitido: 'ya no está en BORRADOR…DESPACHADO' };
    const itemsAntes = new Map<string, number>(
      (await tx.imp_embarque_items.findMany({ where: { embarque_id: id, activo: true }, select: { id: true, costo_total_gs: true } })).map(
        (i: any) => [i.id, redondear(i.costo_total_gs)] as [string, number],
      ),
    );
    let despues: string | null = null;
    let repartoCambia = false;
    // Solo los tres delegados que usa el costeo; en dry las escrituras se descartan y se captura el resultado.
    const proxy: any = {
      imp_embarque_items: {
        findMany: (a: any) => tx.imp_embarque_items.findMany(a),
        update: (a: any) => {
          if (itemsAntes.get(a.where.id) !== redondear(a.data.costo_total_gs)) repartoCambia = true;
          return opciones.dry ? Promise.resolve(null) : tx.imp_embarque_items.update(a);
        },
      },
      imp_componentes_costo: { findMany: (a: any) => tx.imp_componentes_costo.findMany(a) },
      imp_embarques: {
        update: (a: any) => {
          despues = String(a.data.costo_total_gs);
          return opciones.dry ? Promise.resolve(null) : tx.imp_embarques.update(a);
        },
      },
    };
    await costeo.recalcular(proxy, e.empresa_id, e.id);
    const antes = String(Number(e.costo_total_gs ?? 0));
    if (despues === null || (Number(despues) === Number(antes) && !repartoCambia)) return null;
    return { empresa: e.empresas?.razon_social ?? e.empresa_id, numero: e.numero, estado: e.estado, antes, despues };
  };

  const candidatos = await db.imp_embarques.findMany({
    where: filtroEmbarque,
    select,
    orderBy: [{ empresa_id: 'asc' as const }, { numero: 'asc' as const }],
  });
  const salida: CambioCosteo[] = [];
  for (const cand of candidatos as any[]) {
    try {
      const c = await db.$transaction((tx: any) => procesar(tx, cand.id), { timeout: 120000 });
      if (c) salida.push(c.omitido ? { ...c, empresa: cand.empresas?.razon_social ?? cand.empresa_id, numero: cand.numero } : c);
    } catch (e: any) {
      salida.push({
        empresa: cand.empresas?.razon_social ?? cand.empresa_id,
        numero: cand.numero,
        estado: cand.estado,
        antes: String(Number(cand.costo_total_gs ?? 0)),
        despues: '',
        error: { codigo: codigoDe(e), mensaje: String(e?.message ?? e) },
      });
    }
  }
  return salida;
}
