import { OrdenesCompraService } from 'src/ordenes-compra/ordenes-compra.service';
import { RequisicionesService } from './requisiciones.service';

/** Base en memoria compartida por los specs de generar órdenes de compra y de la matriz de configuración. */
export const SUC = 'aaaaaaaa-0000-4000-8000-000000000001';
export const OTRA_SUC = 'aaaaaaaa-0000-4000-8000-000000000002';
export const DET1 = 'cccccccc-0000-4000-8000-000000000001';
export const DET2 = 'cccccccc-0000-4000-8000-000000000002';
export const DET3 = 'cccccccc-0000-4000-8000-000000000003';
export const DET_AJENA = 'cccccccc-0000-4000-8000-000000000099';
export const PROV_A = 'dddddddd-0000-4000-8000-000000000001';
export const PROV_B = 'dddddddd-0000-4000-8000-000000000002';
export const PROD1 = 'eeeeeeee-0000-4000-8000-000000000001';
export const MON_PYG = 'ffffffff-0000-4000-8000-000000000001';
export const MON_USD = 'ffffffff-0000-4000-8000-000000000002';

export const cuerpo = (e: any) => e.getResponse();

export async function error(p: Promise<unknown>): Promise<any> {
  try {
    await p;
  } catch (e) {
    return e;
  }
  throw new Error('Se esperaba un error y no hubo');
}

export const tick = () => new Promise((r) => setImmediate(r));

export interface Opts {
  estado?: string;
  origen?: string;
  config?: Record<string, unknown>;
  /** Pedido en OC abiertas ya existentes, por línea. */
  pedidas?: Array<{ requisicion_det_id: string; cantidad: number; estado?: string }>;
  /** Ejecutado fuera de OC (factura sin línea de OC). */
  facturadas?: Array<{ requisicion_det_id: string; cantidad: number }>;
  gastadas?: Array<{ requisicion_det_id: string; cantidad: number }>;
  /** Proveedor que no existe (hace fallar la OC de ese proveedor dentro de la tx). */
  proveedorInexistente?: string;
  /** Módulo Contabilidad contratado: el centro de costo pasa a ser obligatorio en las OC. */
  contabilidad?: boolean;
}

/**
 * Base en memoria con transacciones de verdad: lo que se escribe en una `$transaction` queda pendiente y solo se ve
 * afuera si el callback termina bien. `pg_advisory_xact_lock` se simula con un mutex por clave, reentrante en la
 * misma tx y liberado al terminarla, así se puede probar quién espera a quién.
 */
export function armar(o: Opts = {}) {
  const orden: string[] = [];
  const req = {
    id: 'req-1',
    empresa_id: 'emp-1',
    numero_requisicion: 'REQ-2026-000001',
    estado: o.estado ?? 'aprobada',
    origen_tipo: o.origen ?? 'compra',
    sucursal_id: SUC,
    descripcion: 'Insumos de oficina',
    activo: true,
    requisicion_det: [
      {
        id: DET1,
        producto_id: PROD1,
        descripcion: null,
        centro_costo_id: null,
        cantidad_solicitada: '10.0000',
        cantidad_ejecutada: '0.0000',
        precio_unitario: '1500.0000',
        porcentaje_iva: '10.00',
        created_at: new Date('2026-10-01T10:00:00Z'),
      },
      {
        id: DET2,
        producto_id: null,
        descripcion: 'Servicio de flete',
        centro_costo_id: null,
        cantidad_solicitada: '2.0000',
        cantidad_ejecutada: '0.0000',
        precio_unitario: '50000.0000',
        porcentaje_iva: '5.00',
        created_at: new Date('2026-10-01T10:00:01Z'),
      },
      {
        id: DET3,
        producto_id: null,
        descripcion: 'Ya pedida',
        centro_costo_id: null,
        cantidad_solicitada: '1.0000',
        cantidad_ejecutada: '0.0000',
        precio_unitario: '1000.0000',
        porcentaje_iva: '10.00',
        created_at: new Date('2026-10-01T10:00:02Z'),
      },
    ],
  };
  const config = {
    empresa_id: 'emp-1',
    habilitar_requisicion_compra: true,
    habilitar_orden_compra: true,
    modo_flujo_compra: 'requisicion_opcional',
    requiere_aprobacion: false,
    usar_workflow: false,
    workflow_obligatorio: false,
    ...(o.config ?? {}),
  };

  const base = {
    ocs: [] as any[],
    ocDets: (o.pedidas ?? [{ requisicion_det_id: DET3, cantidad: 1 }]).map((p, i) => ({
      orden_compra_id: `oc-previa-${i}`,
      requisicion_det_id: p.requisicion_det_id,
      cantidad: p.cantidad,
      _estado: p.estado ?? 'pendiente',
    })),
    historial: [] as any[],
  };
  const locks = new Map<string, Promise<void>>();
  let seq = 0;

  const crearTx = () => {
    const tomados = new Set<string>();
    const liberar: Array<() => void> = [];
    const pend = { ocs: [] as any[], ocDets: [] as any[], historial: [] as any[] };
    const ocs = () => [...base.ocs, ...pend.ocs];
    const ocDets = () => [...base.ocDets, ...pend.ocDets];
    const estadoOc = (id: string) => ocs().find((x) => x.id === id)?.estado;

    const db: any = {
      $executeRaw: jest.fn(async (_s: unknown, clave: string) => {
        orden.push(`lock:${clave}`);
        if (tomados.has(clave)) return 1;
        while (locks.has(clave)) await locks.get(clave);
        let soltar!: () => void;
        locks.set(clave, new Promise<void>((r) => (soltar = r)));
        tomados.add(clave);
        liberar.push(() => {
          locks.delete(clave);
          soltar();
        });
        return 1;
      }),
      $queryRaw: jest.fn().mockResolvedValue([]),
      config_compras: { findUnique: jest.fn().mockResolvedValue(config), create: jest.fn() },
      requisicion_cab: {
        findFirst: jest.fn(async ({ where }: any) => {
          orden.push('lectura:req');
          if (where.id !== req.id || where.empresa_id !== 'emp-1') return null;
          const s = where.sucursal_id;
          if (s !== undefined && !(typeof s === 'string' ? s === req.sucursal_id : s.in.includes(req.sucursal_id))) return null;
          return req;
        }),
        update: jest.fn().mockResolvedValue(undefined),
      },
      requisicion_aprobacion: { updateMany: jest.fn().mockResolvedValue(undefined) },
      requisicion_historial: {
        create: jest.fn(async ({ data }: any) => {
          orden.push(`historial:${data.accion}`);
          pend.historial.push(data);
        }),
      },
      productos: {
        findMany: jest.fn().mockResolvedValue([{ id: PROD1, descripcion: 'Resma A4', cod_producto: 'P-1' }]),
      },
      empresas_sucursales: { findFirst: jest.fn(async ({ where }: any) => ({ id: where.id })) },
      proveedores: {
        findFirst: jest.fn(async ({ where }: any) =>
          where.id === o.proveedorInexistente ? null : { id: where.id, tipo_entidad: 'PROVEEDOR' },
        ),
      },
      moneda: {
        findUnique: jest.fn(async ({ where }: any) => ({ id: where.id, codigo: where.id === MON_USD ? 'USD' : 'PYG' })),
        findFirst: jest.fn().mockResolvedValue({ id: MON_PYG }),
      },
      empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ id: 'em-1', moneda_id: MON_PYG }) },
      suscripciones: { findFirst: jest.fn().mockResolvedValue(o.contabilidad ? { id: 's-1' } : null) },
      suscripcion_modulos: { findFirst: jest.fn().mockResolvedValue(o.contabilidad ? { id: 'sm-1' } : null) },
      cont_centros_costo: { findMany: jest.fn().mockResolvedValue(o.contabilidad ? [{ id: 'cc-1' }] : []) },
      orden_compra_cab: {
        create: jest.fn(async ({ data }: any) => {
          seq += 1;
          const oc = { ...data, id: `oc-nueva-${seq}` };
          orden.push(`oc:${oc.proveedor_id}`);
          pend.ocs.push(oc);
          return oc;
        }),
        count: jest.fn(async () => ocs().length),
        findUnique: jest.fn(async ({ where }: any) => {
          const oc = ocs().find((x) => x.id === where.id);
          return oc ? { id: oc.id, empresa_id: oc.empresa_id, estado: oc.estado, orden_compra_det: [] } : null;
        }),
        findMany: jest.fn(async ({ where }: any) =>
          ocs()
            .filter((x) => x.requisicion_id === where.requisicion_id && !['cancelada', 'completada'].includes(x.estado))
            .map((x) => ({ id: x.id, numero_orden: x.numero_orden })),
        ),
        update: jest.fn().mockResolvedValue(undefined),
      },
      orden_compra_det: {
        createMany: jest.fn(async ({ data }: any) => {
          pend.ocDets.push(...data.map((d: any) => ({ ...d })));
        }),
        findMany: jest.fn(async ({ where }: any) =>
          ocDets()
            .filter((d) => where.requisicion_det_id.in.includes(d.requisicion_det_id))
            .filter((d) => (d._estado ?? estadoOc(d.orden_compra_id)) !== 'cancelada')
            .map((d) => ({ requisicion_det_id: d.requisicion_det_id, cantidad: d.cantidad })),
        ),
      },
      compra_det: {
        findMany: jest.fn(async ({ where }: any) => (where.requisicion_det_id ? (o.facturadas ?? []) : [])),
      },
      gasto_det: { findMany: jest.fn().mockResolvedValue(o.gastadas ?? []) },
    };
    return {
      db,
      commit: () => {
        base.ocs.push(...pend.ocs);
        base.ocDets.push(...pend.ocDets);
        base.historial.push(...pend.historial);
      },
      soltar: () => liberar.forEach((f) => f()),
    };
  };

  // Afuera de una tx, la "conexión" lee lo confirmado.
  const fuera = crearTx();
  const prisma: any = {
    ...fuera.db,
    $transaction: jest.fn(async (cb: any, opts?: any) => {
      orden.push(`tx:${opts?.timeout ?? '-'}`);
      const t = crearTx();
      try {
        const r = await cb(t.db);
        t.commit();
        return r;
      } finally {
        t.soltar();
      }
    }),
  };
  const auditService = { log: jest.fn(async () => orden.push('audit')) };
  const monedasService = { getCotizacionVigente: jest.fn().mockResolvedValue({ tasa: 7300, fuente: 'contabilidad' }) };
  const oc = new OrdenesCompraService(prisma, auditService as any, monedasService as any);
  const service = new RequisicionesService(prisma, oc, { logEnTransaccion: jest.fn() } as any);
  jest.spyOn(service, 'findOne').mockResolvedValue({ id: 'req-1' } as any);
  const crearEnTx = jest.spyOn(oc, 'crearEnTx');
  return { service, oc, prisma, base, orden, req, crearEnTx, auditService };
}

export const dtoBase = (asignaciones: any[], extra: Record<string, unknown> = {}): any => ({
  sucursal_id: SUC,
  moneda_id: MON_PYG,
  fecha_emision: '2026-10-29',
  asignaciones,
  ...extra,
});

export const asig = (requisicion_det_id: string, proveedor_id: string, cantidad?: number, precio_unitario = 1500) => ({
  requisicion_det_id,
  proveedor_id,
  ...(cantidad !== undefined ? { cantidad } : {}),
  precio_unitario,
});
