import { PagosProveedorService } from './pagos-proveedor.service';
import { cumple, Fila } from './where-en-memoria.testutil';

/**
 * Base en memoria y transaccional para el alta, el workflow, la ejecución y el registro en Tesorería de la OP
 * (op-escrituras.spec.ts, concurrencia real; op-config-matriz.spec.ts, la matriz «Probar según configuración»).
 *
 * - `pg_advisory_xact_lock` espera de verdad a que la transacción que tiene la clave termine (el lock se suelta al
 *   confirmar o deshacer), y el `SELECT … FOR UPDATE` de la numeración también toma su lock.
 * - Cada lectura toma la foto en el momento y cede el turno (`setImmediate`), así dos transacciones se intercalan
 *   como en Postgres. Los `where` se evalúan con `where-en-memoria.testutil.ts`.
 * - Commit/rollback reales: cada escritura deja cómo deshacerse; si el callback de `$transaction` tira, se deshace
 *   todo lo que escribió (en orden inverso) y recién después se sueltan sus locks.
 */

export const EMPRESA = 'emp-1';
export const PROVEEDOR = 'prov-1';
export const SUCURSAL = 'suc-1';

export const MONEDAS_BASE = [
  { id: 'mon-pyg', codigo: 'PYG' },
  { id: 'mon-usd', codigo: 'USD' },
];

export const MEDIOS_BASE = [
  { id: 'mp-efectivo', codigo: 1, descripcion: 'Efectivo' },
  { id: 'mp-cheque', codigo: 2, descripcion: 'Cheque' },
  { id: 'mp-tarjeta', codigo: 3, descripcion: 'Tarjeta de crédito' },
  { id: 'mp-transf', codigo: 5, descripcion: 'Transferencia' },
  { id: 'mp-anticipo', codigo: 11, descripcion: 'Pago por anticipo' },
  { id: 'mp-otro', codigo: 99, descripcion: 'Otro' },
];

export const NUMERACION_BASE = {
  id: 'num-1',
  numero_actual: 5,
  numero_final: null,
  punto_expedicion: '001',
  punto_establecimiento: '001',
};

/** Una cuota de PROV-1 con saldo (las columnas que leen el alta y la ejecución). */
export const cuotaBase = (id: string, factura: string, saldo: number, over: Fila = {}): Fila => ({
  id,
  empresa_id: EMPRESA,
  proveedor_id: PROVEEDOR,
  compra_id: `c-${id}`,
  origen_tipo: 'compra',
  origen_id: null,
  moneda_id: 'mon-pyg',
  monto_original: saldo,
  saldo_pendiente: saldo,
  monto_pagado: 0,
  numero_cuota: 1,
  total_cuotas: 1,
  fecha_vencimiento: null,
  estado: 'pendiente',
  activo: true,
  compra_cab: { numero_factura: factura },
  ...over,
});

export type OpcionesBaseOp = {
  config: Fila;
  cuotas?: Fila[];
  /** Órdenes ya existentes (con `orden_pago_proveedor_det`). */
  ordenes?: Fila[];
  /** El usuario tiene `CMP_OP_ORDEN_PAGO_PAGAR` (por defecto sí). */
  pagar?: boolean;
  /** Medios que la empresa marcó `no_mueve_caja`. */
  sinCaja?: string[];
  /** `null`: la sucursal no tiene numeración 400 activa. */
  numeracion?: Fila | null;
  /** `config` de la sucursal (p. ej. `requiere_caja_pagos_proveedor`). */
  configSucursal?: Fila;
  /** Cuentas de Tesorería: `{ id, nombre, moneda, saldo_actual, activo }`. */
  cuentasTes?: Fila[];
  /** Reglas `PAGO_PROVEEDOR`: `{ medio_pago_id (null = por defecto), activo, cuenta_id }`. */
  reglas?: Fila[];
  /** La empresa tiene el módulo Contabilidad (por defecto sí). */
  conContabilidad?: boolean;
  /** Corre el registro en Tesorería de verdad (por defecto se reemplaza por `{}`, como en op-escrituras). */
  tesoreriaReal?: boolean;
  vigente?: { tasa: number; fuente: string };
  /** `gasto_cab` (`{ id, empresa_id, sucursal_id }`) para el alcance por sucursal de las cuotas de gastos. */
  gastos?: Fila[];
};

const copia = <T>(v: T): T =>
  v == null
    ? v
    : JSON.parse(JSON.stringify(v), (_k, x) =>
        typeof x === 'string' && /^\d{4}-\d{2}-\d{2}T/.test(x) ? new Date(x) : x,
      );

export const montarBaseOp = (o: OpcionesBaseOp) => {
  const db = {
    config: o.config,
    ordenes: new Map<string, Fila>((o.ordenes ?? []).map((x): [string, Fila] => [x.id, copia(x)])),
    cuotas: new Map<string, Fila>((o.cuotas ?? []).map((c): [string, Fila] => [c.id, copia(c)])),
    pagos: [] as Fila[],
    movimientos: [] as Fila[],
    movimientoDet: [] as Fila[],
    cheques: [] as Fila[],
    cuentasTes: new Map<string, Fila>(
      (o.cuentasTes ?? []).map((c): [string, Fila] => [c.id, { empresa_id: EMPRESA, activo: true, ...copia(c) }]),
    ),
    reglas: (o.reglas ?? []).map((r) => ({ empresa_id: EMPRESA, tipo_operacion: 'PAGO_PROVEEDOR', ...r })),
    documentosContables: [] as Fila[],
    numeracion: o.numeracion === null ? null : { ...NUMERACION_BASE, ...(o.numeracion ?? {}) },
    /** Transacciones confirmadas y deshechas (para aseverar que una falla no dejó nada). */
    commits: 0,
    rollbacks: 0,
  };
  let altas = 0;
  const colas = new Map<string, Promise<void>>();
  const cede = () => new Promise((r) => setImmediate(r));
  const monedaDe = (id?: string | null) => MONEDAS_BASE.find((m) => m.id === id) ?? null;
  const medioDe = (id?: string | null) => MEDIOS_BASE.find((m) => m.id === id) ?? null;

  const tomar = async (clave: string, soltar: Array<() => void>) => {
    const previa = colas.get(clave) ?? Promise.resolve();
    let suelta!: () => void;
    const propia = new Promise<void>((r) => (suelta = r));
    colas.set(
      clave,
      previa.then(() => propia),
    );
    await previa;
    soltar.push(suelta);
  };
  /** La lectura toma la foto en el momento y después cede el turno (la latencia de la base). */
  const leer = async <T>(v: T) => {
    const foto = copia(v);
    await cede();
    return foto;
  };
  /** La orden como la devuelve Prisma con sus relaciones (moneda y medio de cada línea). */
  const conRelaciones = (orden: Fila | undefined | null) =>
    orden
      ? {
          ...orden,
          moneda: monedaDe(orden.moneda_id) ? { codigo: monedaDe(orden.moneda_id).codigo } : null,
          orden_pago_proveedor_det: (orden.orden_pago_proveedor_det ?? []).map((d: Fila) => ({
            ...d,
            medio_pago: medioDe(d.medio_pago_id),
          })),
        }
      : null;

  /** `deshacer`: null fuera de una transacción (lecturas sueltas). */
  const crearTx = (soltar: Array<() => void>, deshacer: Array<() => void> | null) => {
    const anotar = (f: () => void) => deshacer?.push(f);
    const cambiar = (fila: Fila, data: Fila) => {
      const antes = copia(fila);
      anotar(() => {
        for (const k of Object.keys(fila)) delete fila[k];
        Object.assign(fila, antes);
      });
      Object.assign(fila, data);
      return fila;
    };
    const agregar = (lista: Fila[], fila: Fila) => {
      lista.push(fila);
      anotar(() => lista.splice(lista.indexOf(fila), 1));
      return fila;
    };

    return {
      $executeRaw: jest.fn(async (_s: unknown, clave: string) => {
        await tomar(String(clave), soltar);
        return 1;
      }),
      $queryRaw: jest.fn(async (sql: { sql?: string }) => {
        if (deshacer && String(sql?.sql ?? '').includes('FOR UPDATE')) await tomar('numeracion:num-1', soltar);
        return leer(db.numeracion ? [db.numeracion] : []);
      }),
      config_compras: { findUnique: jest.fn(async () => leer(db.config)), create: jest.fn() },
      proveedores: { findFirst: jest.fn(async () => leer({ id: PROVEEDOR })) },
      empresas_sucursales: {
        findFirst: jest.fn(async ({ where }: any) =>
          leer(where.id === SUCURSAL ? { id: SUCURSAL, config: o.configSucursal ?? {} } : null),
        ),
      },
      sesiones_caja: { findFirst: jest.fn(() => null) },
      medio_pago: {
        findMany: jest.fn(async ({ where }: any) => leer(MEDIOS_BASE.filter((m) => where.id.in.includes(m.id)))),
      },
      empresa_medio_pago: {
        findMany: jest.fn(async () => leer((o.sinCaja ?? []).map((medio_pago_id) => ({ medio_pago_id })))),
        findFirst: jest.fn(() => null),
      },
      usuario: { findUnique: jest.fn(() => ({ is_superadmin: false })) },
      perfiles_privilegios: { findFirst: jest.fn(() => (o.pagar === false ? null : { id: 'pp-pagar' })) },
      moneda: {
        findUnique: jest.fn(async ({ where }: any) => leer(monedaDe(where.id))),
        findFirst: jest.fn(async ({ where }: any) =>
          leer(MONEDAS_BASE.find((m) => (where.id ? m.id === where.id : m.codigo === where.codigo)) ?? null),
        ),
      },
      empresa_monedas: { findFirst: jest.fn(async () => leer({ moneda_id: 'mon-pyg' })) },
      numeraciones_documento: {
        update: jest.fn(({ data }: any) => {
          if (db.numeracion && data.numero_actual !== undefined)
            cambiar(db.numeracion, { numero_actual: data.numero_actual });
        }),
      },
      cuentas_pagar: {
        findMany: jest.fn(async ({ where }: any) => leer([...db.cuotas.values()].filter((c) => cumple(c, where)))),
        update: jest.fn(({ where, data }: any) => cambiar(db.cuotas.get(where.id), data)),
      },
      pagos_proveedor: { create: jest.fn(({ data }: any) => agregar(db.pagos, { ...data })) },
      orden_pago_proveedor_cab: {
        findFirst: jest.fn(async ({ where }: any) =>
          leer(conRelaciones([...db.ordenes.values()].find((x) => cumple(x, where)))),
        ),
        findMany: jest.fn(async ({ where }: any) =>
          leer([...db.ordenes.values()].filter((x) => cumple(x, where)).map(conRelaciones)),
        ),
        update: jest.fn(({ where, data }: any) => cambiar(db.ordenes.get(where.id), data)),
        create: jest.fn(({ data }: any) => {
          const id = `op-alta-${++altas}`;
          db.ordenes.set(id, { ...data, id, orden_pago_proveedor_det: [] });
          anotar(() => db.ordenes.delete(id));
          return { id, numero_orden_pago: data.numero_orden_pago };
        }),
      },
      orden_pago_proveedor_det: {
        create: jest.fn(({ data }: any) =>
          agregar(db.ordenes.get(data.orden_pago_id).orden_pago_proveedor_det, { ...data }),
        ),
        // `ordenesAbiertasPorCuota`: las líneas de esas cuotas cuya cabecera cumple `whereOrdenAbierta`.
        findMany: jest.fn(async ({ where }: any) => {
          const { cuenta_pagar_id, orden_pago_proveedor_cab: whereCab } = where;
          const filas = [...db.ordenes.values()]
            .filter((x) => cumple(x, whereCab))
            .flatMap((x) =>
              (x.orden_pago_proveedor_det as Fila[])
                .filter((d) => cumple(d, { cuenta_pagar_id }))
                .map((d) => ({
                  cuenta_pagar_id: d.cuenta_pagar_id,
                  orden_pago_proveedor_cab: {
                    id: x.id,
                    numero_orden_pago: x.numero_orden_pago,
                    estado: x.estado,
                    fecha_pago: x.fecha_pago,
                  },
                })),
            );
          return leer(filas);
        }),
      },
      tes_cheques: {
        findFirst: jest.fn(async ({ where }: any) => leer(db.cheques.find((c) => cumple(c, where)) ?? null)),
        findMany: jest.fn(async ({ where }: any) => leer(db.cheques.filter((c) => cumple(c, where)))),
        create: jest.fn(({ data }: any) => agregar(db.cheques, { id: `ch-${db.cheques.length + 1}`, ...data })),
      },
      tes_movimientos: {
        findFirst: jest.fn(async ({ where }: any) => leer(db.movimientos.find((m) => cumple(m, where)) ?? null)),
        findMany: jest.fn(async ({ where }: any) => leer(db.movimientos.filter((m) => cumple(m, where)))),
        create: jest.fn(({ data }: any) =>
          agregar(db.movimientos, { id: `mov-${db.movimientos.length + 1}`, ...data }),
        ),
      },
      tes_movimiento_det: { create: jest.fn(({ data }: any) => agregar(db.movimientoDet, { ...data })) },
      tes_categorias: { findFirst: jest.fn(() => ({ id: 'cat-pago-proveedor' })), create: jest.fn() },
      tes_reglas: {
        findFirst: jest.fn(async ({ where }: any) => leer(db.reglas.find((r) => cumple(r, where)) ?? null)),
      },
      tes_cuentas: {
        findFirst: jest.fn(async ({ where }: any) =>
          leer([...db.cuentasTes.values()].find((c) => cumple(c, where)) ?? null),
        ),
        findMany: jest.fn(async ({ where }: any) => leer([...db.cuentasTes.values()].filter((c) => cumple(c, where)))),
        update: jest.fn(({ where, data }: any) => {
          const c = db.cuentasTes.get(where.id);
          const delta = data.saldo_actual?.increment ?? -(data.saldo_actual?.decrement ?? 0);
          return cambiar(c, { saldo_actual: Number(c.saldo_actual ?? 0) + delta });
        }),
      },
      cont_documentos: {
        findMany: jest.fn(async ({ where }: any) => leer(db.documentosContables.filter((d) => cumple(d, where)))),
        findFirst: jest.fn(async ({ where }: any) =>
          leer(db.documentosContables.find((d) => cumple(d, where)) ?? null),
        ),
      },
      audit_logs: { findFirst: jest.fn(() => null) },
      // `whereAlcanceCuotas`: los gastos de las sucursales del alcance (`gastos` de las opciones).
      gasto_cab: { findMany: jest.fn(async ({ where }: any) => leer((o.gastos ?? []).filter((g) => cumple(g, where)))) },
    };
  };

  const prisma: any = {
    $transaction: jest.fn(async (cb: (t: any) => unknown) => {
      const soltar: Array<() => void> = [];
      const deshacer: Array<() => void> = [];
      try {
        const r = await cb(crearTx(soltar, deshacer));
        db.commits++;
        return r;
      } catch (e) {
        deshacer.reverse().forEach((f) => f());
        db.rollbacks++;
        throw e;
      } finally {
        soltar.forEach((s) => s());
      }
    }),
  };
  // Lecturas fuera de transacción (findOne de los reintentos, cuentaPago, los estados en lote).
  Object.assign(prisma, crearTx([], null));

  const contab = {
    integrarOrdenPago: jest.fn().mockResolvedValue(undefined),
    tieneModuloContabilidad: jest.fn().mockResolvedValue(o.conContabilidad ?? true),
  };
  const audit = { log: jest.fn().mockResolvedValue(undefined) };
  const monedas = {
    getCotizacionVigente: jest.fn().mockResolvedValue(o.vigente ?? { tasa: 7300, fuente: 'contabilidad' }),
  };
  const service = new PagosProveedorService(prisma, contab as any, audit as any, monedas as any);
  // El detalle lo prueba op-lecturas.spec.ts: acá alcanza con la fila tal cual quedó.
  jest
    .spyOn(service, 'findOne')
    .mockImplementation((id: string) => Promise.resolve(copia(db.ordenes.get(id) ?? { id }) as any));
  if (!o.tesoreriaReal) jest.spyOn(service, 'syncTesoreriaOrdenPago').mockResolvedValue({});
  for (const m of ['recalculateCompraEstado', 'recalculateAutoOrderEstado', 'recalculateGastoEstado']) {
    jest.spyOn(service as any, m).mockResolvedValue(undefined);
  }
  return { service, prisma, db, contab, audit, monedas };
};
