import { Prisma } from '@prisma/client';
import { TesChequeService } from '../tes-cheques.service';

/**
 * Prisma, integrador, auditoría y configuración mockeados para `TesChequeService` (specs de S4). `$transaction` corre el callback
 * con un `tx` distinto del `prisma` y propaga lo que lance. Quien lo usa mockea en su spec `module-access.util`,
 * `submodulo.guard` y `ymdInAsuncion` (jest.mock va en el archivo del spec).
 */
export const EMP = '0e000000-0000-4000-8000-000000000001';
export const USER = 'u-1';
export const ID = 'e9a10000-0000-4000-8000-0000000000c1';
export const CTA_PYG = 'c7a00000-0000-4000-8000-000000000001';
export const CTA_USD = 'c7a00000-0000-4000-8000-000000000002';
export const MOV = '30000000-0000-4000-8000-000000000001';

export const CUENTAS: Record<string, Record<string, unknown>> = {
  [CTA_PYG]: { id: CTA_PYG, empresa_id: EMP, nombre: 'DOBA S.A.', moneda: 'PYG', activo: true, banco_id: 'b-1', numero_cuenta: '123' },
  [CTA_USD]: { id: CTA_USD, empresa_id: EMP, nombre: 'DOBA S.A. DOLARES', moneda: 'USD', activo: true, banco_id: null, numero_cuenta: null },
};

export const movimiento = (o: Record<string, unknown> = {}) => ({
  id: MOV,
  estado: 'CONFIRMADO',
  cuenta_id: CTA_PYG,
  monto: new Prisma.Decimal(2500000),
  tipo: 'INGRESO',
  origen_tipo: 'CHEQUE_DEPOSITADO',
  cuenta: { nombre: 'DOBA S.A.', activo: true },
  ...o,
});

/** Un cheque como lo trae `findFirst` con el include de lectura (todas las columnas, `cuenta` y `movimiento`). */
export const cheque = (o: Record<string, unknown> = {}) => ({
  id: ID,
  empresa_id: EMP,
  tipo: 'RECIBIDO',
  estado: 'EN_CARTERA',
  numero_cheque: '7294512',
  banco_emisor: 'Banco Familiar',
  cuenta_bancaria_origen: null,
  titular: 'Juan Pérez',
  monto: new Prisma.Decimal(2500000),
  moneda: 'PYG',
  fecha_emision: new Date('2026-10-01T00:00:00.000Z'),
  fecha_vencimiento: null as Date | null,
  cuenta_id: null as string | null,
  movimiento_id: null as string | null,
  origen_tipo: null as string | null,
  origen_id: null as string | null,
  referencia: null,
  motivo: null,
  registrado_por: USER,
  acreditado_en: null,
  created_at: new Date('2026-10-01T12:00:00.000Z'),
  updated_at: new Date('2026-10-01T12:00:00.000Z'),
  cuenta: null as Record<string, unknown> | null,
  movimiento: null as Record<string, unknown> | null,
  ...o,
});

export interface Escenario {
  /** Lo que lee `tes_cheques.findFirst` (la primera vez; después, `despues` si viene). */
  cheque?: Record<string, unknown> | null;
  despues?: Record<string, unknown>;
  chequesLista?: Array<Record<string, unknown>>;
  /** `updateMany` / `deleteMany` de `tes_cheques` en el `tx`. */
  cuenta?: number;
  /** `updateMany` del movimiento en el `tx` (Deshacer). */
  cuentaMovimiento?: number;
  /** Línea conciliada: antes de la tx y dentro de la tx. */
  conciliado?: boolean;
  conciliadoEnTx?: boolean;
  /** Para las filas: movimientos, líneas conciliadas y documentos contables. */
  movimientos?: Array<Record<string, unknown>>;
  lineas?: Array<Record<string, unknown>>;
  documentos?: Array<Record<string, unknown>>;
  recibos?: Array<Record<string, unknown>>;
  config?: Record<string, unknown> | null;
  integrador?: jest.Mock;
  revertir?: jest.Mock;
  constancia?: Record<string, unknown> | null;
}

export function armar(e: Escenario = {}) {
  let lecturas = 0;
  const leido = e.cheque === undefined ? cheque() : e.cheque;
  const tx = {
    $queryRaw: jest.fn().mockResolvedValue([{ id: MOV }]),
    tes_cheques: {
      updateMany: jest.fn().mockResolvedValue({ count: e.cuenta ?? 1 }),
      deleteMany: jest.fn().mockResolvedValue({ count: e.cuenta ?? 1 }),
      update: jest.fn().mockResolvedValue({}),
    },
    tes_movimientos: {
      create: jest.fn().mockImplementation(({ data }: { data: Record<string, unknown> }) => Promise.resolve({ id: 'mov-nuevo', ...data })),
      updateMany: jest.fn().mockResolvedValue({ count: e.cuentaMovimiento ?? 1 }),
    },
    tes_cuentas: { update: jest.fn().mockResolvedValue({}) },
    tes_extracto_lineas: { findFirst: jest.fn().mockResolvedValue(e.conciliadoEnTx ? { id: 'lin-1' } : null) },
  };
  const tabla = (filas: Array<Record<string, unknown>> = []) => ({ findMany: jest.fn().mockResolvedValue(filas) });
  const prisma: any = {
    $transaction: jest.fn().mockImplementation((cb: (t: typeof tx) => unknown) => cb(tx)),
    tes_cheques: {
      findFirst: jest.fn().mockImplementation(() => Promise.resolve(lecturas++ === 0 ? leido : (e.despues ?? leido))),
      findMany: jest.fn().mockResolvedValue(e.chequesLista ?? []),
      create: jest.fn().mockImplementation(({ data }: { data: Record<string, unknown> }) => Promise.resolve(cheque({ ...data, cuenta: null }))),
    },
    tes_cuentas: {
      findFirst: jest.fn().mockImplementation(({ where }: { where: { id: string; activo?: boolean } }) => {
        const c = CUENTAS[where.id];
        return Promise.resolve(c && (where.activo === undefined || c.activo === where.activo) ? c : null);
      }),
      findMany: jest.fn().mockResolvedValue(Object.values(CUENTAS)),
    },
    bancos: {
      findMany: jest.fn().mockResolvedValue([{ id: 'b-1', descripcion: 'Banco Continental' }]),
      findUnique: jest.fn().mockResolvedValue({ descripcion: 'Banco Continental' }),
    },
    tes_categorias: { findFirst: jest.fn().mockResolvedValue({ id: 'cat-1' }), create: jest.fn().mockResolvedValue({ id: 'cat-1' }) },
    tes_movimientos: { findMany: jest.fn().mockResolvedValue(e.movimientos ?? []) },
    tes_extracto_lineas: { findFirst: jest.fn().mockResolvedValue(e.conciliado ? { id: 'lin-1' } : null), findMany: jest.fn().mockResolvedValue(e.lineas ?? []) },
    cont_documentos: { findMany: jest.fn().mockResolvedValue(e.documentos ?? []) },
    audit_logs: { findFirst: jest.fn().mockResolvedValue(e.constancia ?? null) },
    recibos_cobro: tabla(e.recibos),
    gasto_cab: tabla(),
    orden_pago_proveedor_cab: tabla(),
    rendicion_adelanto: tabla(),
    rendicion_devolucion: tabla(),
  };
  const contabilidad = {
    integrarMovimientoTesoreria: e.integrador ?? jest.fn().mockResolvedValue({ generado: true }),
    revertirDocumento: e.revertir ?? jest.fn().mockResolvedValue(undefined),
  };
  const audit = { log: jest.fn().mockResolvedValue(undefined) };
  const tesConfig = { get: jest.fn().mockResolvedValue(e.config === undefined ? { dias_alerta_cheques: 7 } : e.config) };
  const service = new TesChequeService(prisma, contabilidad as never, audit as never, tesConfig as never);
  return { service, prisma, tx, contabilidad, audit, tesConfig };
}

/** El cuerpo `{ codigo, campo?, message }` de un error estructurado (o `undefined` si no lanzó). */
export async function errorDe(p: Promise<unknown>): Promise<{ status: number; codigo?: string; campo?: string; message?: string } | undefined> {
  try {
    await p;
    return undefined;
  } catch (e) {
    const err = e as { getStatus?: () => number; getResponse?: () => unknown };
    const cuerpo = (err.getResponse?.() ?? {}) as Record<string, unknown>;
    return { status: err.getStatus?.() ?? 500, ...(cuerpo as object) } as never;
  }
}
