import { Prisma } from '@prisma/client';
import { plainToInstance } from 'class-transformer';
import { validateSync } from 'class-validator';
import { hoyComoFechaPY } from 'src/lotes/hoy-py';
import { OrdenPagoProveedorDetalleDto } from './dto/create-orden-pago-proveedor.dto';
import {
  ESTADOS_CUOTA,
  ESTADOS_OP,
  EstadoCuota,
  EstadoOp,
  FILTRO_CON_SALDO,
  aplicaPagoAlGuardar,
  contabilidadEstadoOp,
  estadoCuotaPagar,
  estadoOpClave,
  observacionesTarjeta,
  requiereAprobacionOrdenPago,
  tesoreriaEstadoOp,
  validarDatosMedio,
  whereEstadoCuota,
  whereEstadoOp,
} from './reglas-op';

// ─── Evaluador mínimo de un `where` de Prisma sobre una fila (semántica SQL: NULL no compara) ───
type Fila = Record<string, unknown>;
const comparable = (v: unknown): number | string | boolean => {
  if (v instanceof Date) return v.getTime();
  if (v instanceof Prisma.Decimal) return v.toNumber();
  if (typeof v === 'number' || typeof v === 'boolean') return v;
  const s = String(v);
  return s !== '' && !Number.isNaN(Number(s)) ? Number(s) : s;
};
const esOperador = (v: unknown) =>
  v != null && typeof v === 'object' && !(v instanceof Date) && !(v instanceof Prisma.Decimal);
function cumpleCampo(valor: unknown, cond: unknown): boolean {
  if (cond === null) return valor == null;
  if (!esOperador(cond)) return valor != null && comparable(valor) === comparable(cond);
  return Object.entries(cond as Record<string, unknown>).every(([op, arg]) => {
    if (op === 'equals') return cumpleCampo(valor, arg);
    if (op === 'not') return arg === null ? valor != null : valor != null && !cumpleCampo(valor, arg);
    if (valor == null) return false;
    const a = comparable(valor);
    if (op === 'in') return (arg as unknown[]).some((x) => comparable(x) === a);
    if (op === 'notIn') return !(arg as unknown[]).some((x) => comparable(x) === a);
    const b = comparable(arg);
    if (op === 'lt') return a < b;
    if (op === 'lte') return a <= b;
    if (op === 'gt') return a > b;
    if (op === 'gte') return a >= b;
    throw new Error(`operador sin soporte en el evaluador: ${op}`);
  });
}
function evaluar(where: Record<string, unknown> | undefined, fila: Fila): boolean {
  if (!where) return true;
  return Object.entries(where).every(([k, v]) => {
    const lista = (x: unknown) => (Array.isArray(x) ? x : [x]) as Record<string, unknown>[];
    if (k === 'AND') return lista(v).every((w) => evaluar(w, fila));
    if (k === 'OR') return lista(v).some((w) => evaluar(w, fila));
    if (k === 'NOT') return !lista(v).every((w) => evaluar(w, fila));
    return cumpleCampo(fila[k], v);
  });
}

const dia = (ymd: string) => new Date(`${ymd}T00:00:00.000Z`);

function errorDe(fn: () => void): Record<string, unknown> {
  try {
    fn();
  } catch (e: any) {
    return { status: e.getStatus?.(), ...(e.getResponse?.() as object) };
  }
  throw new Error('no lanzó');
}

describe('reglas-op', () => {
  // ─── Estados de la OP ───
  describe('estadoOpClave y whereEstadoOp', () => {
    const FILAS_OP: Array<[Fila, EstadoOp]> = [
      [{ estado: 'BORRADOR', anulado: false }, 'borrador'],
      [{ estado: 'pendiente', anulado: false }, 'borrador'],
      [{ estado: null, anulado: null }, 'borrador'],
      [{ estado: 'PENDIENTE_APROBACION', anulado: false }, 'pendiente_aprobacion'],
      [{ estado: 'RECHAZADA', anulado: false }, 'rechazada'],
      [{ estado: 'PENDIENTE', anulado: false }, 'aprobada'],
      [{ estado: 'PENDIENTE', anulado: null }, 'aprobada'],
      [{ estado: 'PAGADO', anulado: false }, 'pagada'],
      [{ estado: 'APLICADO', anulado: false }, 'pagada'],
      [{ estado: 'aplicado', anulado: false }, 'pagada'],
      [{ estado: 'ANULADA', anulado: true }, 'anulada'],
      [{ estado: 'ANULADA', anulado: false }, 'anulada'],
      [{ estado: 'PAGADO', anulado: true }, 'anulada'],
      [{ estado: 'BORRADOR', anulado: true }, 'anulada'],
    ];

    it('ESTADOS_OP', () =>
      expect([...ESTADOS_OP]).toEqual([
        'borrador',
        'pendiente_aprobacion',
        'rechazada',
        'aprobada',
        'pagada',
        'anulada',
      ]));

    it.each(FILAS_OP)('estadoOpClave(%o) = %s', (fila, clave) => {
      expect(estadoOpClave(fila as any)).toBe(clave);
    });

    it('cada fila: el filtro y la columna coinciden (sale en el filtro de su clave y en ningún otro)', () => {
      for (const [fila] of FILAS_OP) {
        for (const clave of ESTADOS_OP) {
          expect({ fila, clave, en_filtro: evaluar(whereEstadoOp(clave) as any, fila) }).toEqual({
            fila,
            clave,
            en_filtro: estadoOpClave(fila as any) === clave,
          });
        }
      }
    });

    it('whereEstadoOp(aprobada) pide PENDIENTE en mayúscula y borrador no la incluye (bug 1)', () => {
      expect(JSON.stringify(whereEstadoOp('aprobada'))).toContain('"estado":"PENDIENTE"');
      expect(evaluar(whereEstadoOp('aprobada') as any, { estado: 'pendiente', anulado: false })).toBe(false);
      expect(evaluar(whereEstadoOp('borrador') as any, { estado: 'PENDIENTE', anulado: false })).toBe(false);
      expect(evaluar(whereEstadoOp('borrador') as any, { estado: 'pendiente', anulado: false })).toBe(true);
    });
  });

  // ─── Aprobación (matriz del spec) ───
  describe('requiereAprobacionOrdenPago y aplicaPagoAlGuardar', () => {
    const REAL = {
      requiere_aprobacion: false,
      usar_workflow: false,
      workflow_obligatorio: false,
      permite_pago_sin_aprobacion: true,
      aplicar_pago_al_guardar: true,
    };
    it('fila 1 (real de las 9 empresas): sin aprobación, paga al guardar', () => {
      expect(requiereAprobacionOrdenPago(REAL)).toBe(false);
      expect(aplicaPagoAlGuardar(REAL)).toBe(true);
    });
    it('fila 4: requiere_aprobacion sin permite_pago_sin_aprobacion pide aprobación y no paga al guardar', () => {
      const c = { ...REAL, requiere_aprobacion: true, permite_pago_sin_aprobacion: false };
      expect(requiereAprobacionOrdenPago(c)).toBe(true);
      expect(aplicaPagoAlGuardar(c)).toBe(false);
      const conWorkflow = { ...REAL, usar_workflow: true, permite_pago_sin_aprobacion: false };
      expect(requiereAprobacionOrdenPago(conWorkflow)).toBe(true);
    });
    it('fila 5: requiere_aprobacion + permite_pago_sin_aprobacion no pide aprobación (como 1 o 3)', () => {
      const c = { ...REAL, requiere_aprobacion: true };
      expect(requiereAprobacionOrdenPago(c)).toBe(false);
      expect(aplicaPagoAlGuardar(c)).toBe(true);
      expect(aplicaPagoAlGuardar({ ...c, aplicar_pago_al_guardar: false })).toBe(false);
    });
    it('fila 6: workflow_obligatorio pide aprobación aunque permita pagar sin aprobación', () => {
      const c = { ...REAL, workflow_obligatorio: true };
      expect(requiereAprobacionOrdenPago(c)).toBe(true);
      expect(aplicaPagoAlGuardar(c)).toBe(false);
    });
    it('sin config (nulls) no pide aprobación ni paga al guardar', () => {
      expect(requiereAprobacionOrdenPago({})).toBe(false);
      expect(aplicaPagoAlGuardar({})).toBe(false);
    });
  });

  // ─── Estado de la cuota ───
  describe('estadoCuotaPagar y whereEstadoCuota', () => {
    const HOY = dia('2026-10-06');
    const base = {
      estado: 'pendiente',
      activo: true,
      monto_pagado: '0.00',
      saldo_pendiente: '100.00',
      fecha_vencimiento: dia('2026-10-10'),
    };
    const FILAS_CUOTA: Array<[string, Fila, EstadoCuota]> = [
      [
        'anulada por estado aunque tenga saldo y venció',
        { ...base, estado: 'anulada', fecha_vencimiento: dia('2026-01-01') },
        'anulada',
      ],
      ['anulada por activo = false', { ...base, activo: false, saldo_pendiente: '0.00' }, 'anulada'],
      [
        'pagada (saldo 0) aunque venció',
        {
          ...base,
          estado: 'pagada',
          saldo_pendiente: '0.00',
          monto_pagado: '100.00',
          fecha_vencimiento: dia('2026-01-01'),
        },
        'pagada',
      ],
      ['pagada con saldo negativo', { ...base, saldo_pendiente: '-0.01' }, 'pagada'],
      [
        'vencida con pago parcial',
        { ...base, estado: 'parcial', monto_pagado: '10.00', fecha_vencimiento: dia('2026-10-05') },
        'vencida',
      ],
      ['vencida sin pago', { ...base, fecha_vencimiento: dia('2026-10-05') }, 'vencida'],
      ['parcial que vence hoy', { ...base, monto_pagado: '10.00', fecha_vencimiento: HOY }, 'parcial'],
      ['parcial sin vencimiento', { ...base, monto_pagado: '10.00', fecha_vencimiento: null }, 'parcial'],
      ['pendiente que vence hoy', { ...base, fecha_vencimiento: HOY }, 'pendiente'],
      ['pendiente sin vencimiento', { ...base, fecha_vencimiento: null }, 'pendiente'],
      ['pendiente con estado y activo en NULL', { ...base, estado: null, activo: null }, 'pendiente'],
      ['pagada con saldo NULL', { ...base, saldo_pendiente: null }, 'pagada'],
      ['pendiente con monto_pagado NULL', { ...base, monto_pagado: null }, 'pendiente'],
      [
        'decimal de Prisma',
        { ...base, saldo_pendiente: new Prisma.Decimal('5'), monto_pagado: new Prisma.Decimal('1') },
        'parcial',
      ],
    ];

    it('ESTADOS_CUOTA y FILTRO_CON_SALDO', () => {
      expect([...ESTADOS_CUOTA]).toEqual(['pendiente', 'parcial', 'vencida', 'pagada', 'anulada']);
      expect(FILTRO_CON_SALDO).toBe('con_saldo');
    });

    it.each(FILAS_CUOTA)('%s', (_n, fila, clave) => {
      expect(estadoCuotaPagar(fila as any, HOY)).toBe(clave);
    });

    it('cada fila: el filtro y la columna coinciden, y con_saldo = pendiente + parcial + vencida', () => {
      for (const [nombre, fila] of FILAS_CUOTA) {
        const clave = estadoCuotaPagar(fila as any, HOY);
        for (const c of ESTADOS_CUOTA) {
          expect({ nombre, c, en_filtro: evaluar(whereEstadoCuota(c, HOY) as any, fila) }).toEqual({
            nombre,
            c,
            en_filtro: clave === c,
          });
        }
        expect({ nombre, con_saldo: evaluar(whereEstadoCuota(FILTRO_CON_SALDO, HOY) as any, fila) }).toEqual({
          nombre,
          con_saldo: ['pendiente', 'parcial', 'vencida'].includes(clave),
        });
      }
    });

    it('a las 01:30 UTC del 06/10, con hoy = hoyComoFechaPY(), una cuota que vence el 05/10 está pendiente y una del 04/10 vencida', () => {
      jest.useFakeTimers().setSystemTime(new Date('2026-10-06T01:30:00.000Z'));
      try {
        const hoy = hoyComoFechaPY();
        expect(hoy.toISOString()).toBe('2026-10-05T00:00:00.000Z');
        expect(estadoCuotaPagar({ ...base, fecha_vencimiento: dia('2026-10-05') } as any, hoy)).toBe('pendiente');
        expect(estadoCuotaPagar({ ...base, fecha_vencimiento: dia('2026-10-04') } as any, hoy)).toBe('vencida');
        expect(
          evaluar(whereEstadoCuota('vencida', hoy) as any, { ...base, fecha_vencimiento: dia('2026-10-05') }),
        ).toBe(false);
        expect(
          evaluar(whereEstadoCuota('vencida', hoy) as any, { ...base, fecha_vencimiento: dia('2026-10-04') }),
        ).toBe(true);
      } finally {
        jest.useRealTimers();
      }
    });

    it("whereEstadoCuota('con_saldo'): no anulada y saldo > 0", () => {
      expect(whereEstadoCuota('con_saldo', HOY)).toEqual({
        AND: [
          { OR: [{ estado: null }, { estado: { not: 'anulada' } }] },
          { OR: [{ activo: null }, { activo: true }] },
          { saldo_pendiente: { gt: 0 } },
        ],
      });
    });
  });

  // ─── Tesorería y contabilidad ───
  describe('tesoreriaEstadoOp', () => {
    const efectivo = { codigo: 1, no_mueve_caja: false };
    const pagada = { origen: 'manual', estado_clave: 'pagada' as EstadoOp, medios: [efectivo] };
    it('automática → null (la registra la factura)', () => {
      expect(tesoreriaEstadoOp({ ...pagada, origen: 'compra_auto' }, { estado: 'CONFIRMADO' }, null)).toBeNull();
      expect(tesoreriaEstadoOp({ ...pagada, origen: 'compra_auto' }, null, null)).toBeNull();
    });
    it('no pagada → null', () => {
      for (const estado_clave of [
        'borrador',
        'pendiente_aprobacion',
        'rechazada',
        'aprobada',
        'anulada',
      ] as EstadoOp[]) {
        expect(tesoreriaEstadoOp({ ...pagada, estado_clave }, null, null)).toBeNull();
      }
    });
    it('sin caja (todas las líneas con un medio que no mueve dinero) → null', () => {
      expect(tesoreriaEstadoOp({ ...pagada, medios: [{ codigo: 11 }] }, null, null)).toBeNull();
      expect(
        tesoreriaEstadoOp({ ...pagada, medios: [{ codigo: 22, no_mueve_caja: true }, { codigo: 11 }] }, null, null),
      ).toBeNull();
    });
    it('sin egreso ni cheque → PENDIENTE (también si una sola línea mueve dinero o el egreso está ANULADO)', () => {
      expect(tesoreriaEstadoOp(pagada, null, null)).toBe('PENDIENTE');
      expect(tesoreriaEstadoOp({ ...pagada, medios: [{ codigo: 11 }, efectivo] }, null, null)).toBe('PENDIENTE');
      expect(tesoreriaEstadoOp(pagada, { estado: 'ANULADO' }, undefined)).toBe('PENDIENTE');
    });
    it('manual pagada sin medios (medios: []) → PENDIENTE, no null', () => {
      expect(tesoreriaEstadoOp({ ...pagada, medios: [] }, null, null)).toBe('PENDIENTE');
    });
    it('el estado del egreso o del cheque vigente; con cheque DIFERIDO → DIFERIDO', () => {
      expect(tesoreriaEstadoOp(pagada, null, { estado: 'DIFERIDO' })).toBe('DIFERIDO');
      expect(tesoreriaEstadoOp(pagada, { estado: 'CONFIRMADO' }, null)).toBe('CONFIRMADO');
      expect(tesoreriaEstadoOp(pagada, { estado: 'ANULADO' }, { estado: 'EN_CARTERA' })).toBe('EN_CARTERA');
    });
  });

  describe('contabilidadEstadoOp', () => {
    const pagada = { origen: 'manual', estado_clave: 'pagada' as EstadoOp };
    it('sin módulo Contabilidad → null', () => {
      expect(contabilidadEstadoOp(pagada, { estado: 'CONFIRMADO' }, false)).toBeNull();
      expect(contabilidadEstadoOp(pagada, null, false)).toBeNull();
    });
    it('automática → null', () =>
      expect(contabilidadEstadoOp({ ...pagada, origen: 'compra_auto' }, null, true)).toBeNull());
    it('CONFIRMADO → ASENTADO; BORRADOR → BORRADOR', () => {
      expect(contabilidadEstadoOp(pagada, { estado: 'CONFIRMADO' }, true)).toBe('ASENTADO');
      expect(contabilidadEstadoOp(pagada, { estado: 'BORRADOR' }, true)).toBe('BORRADOR');
    });
    it('sin documento (o revertido) y pagada → PENDIENTE; no pagada → null', () => {
      expect(contabilidadEstadoOp(pagada, null, true)).toBe('PENDIENTE');
      expect(contabilidadEstadoOp(pagada, { estado: 'REVERTIDO' }, true)).toBe('PENDIENTE');
      expect(contabilidadEstadoOp({ ...pagada, estado_clave: 'borrador' }, null, true)).toBeNull();
      expect(contabilidadEstadoOp({ ...pagada, estado_clave: 'anulada' }, { estado: 'REVERTIDO' }, true)).toBeNull();
    });
  });

  // ─── Datos del medio ───
  describe('validarDatosMedio', () => {
    const CHEQUE = { codigo: 2, descripcion: 'Cheque', no_mueve_caja: false };
    const TRANSFERENCIA = { codigo: 5, descripcion: 'Transferencia', no_mueve_caja: false };
    const DEPOSITO = { codigo: null, descripcion: 'Depósito bancario', no_mueve_caja: false };
    const TARJETA = { codigo: 3, descripcion: 'Tarjeta de crédito', no_mueve_caja: false };
    const chequeCompleto = {
      numero_cheque: '000123',
      banco_emisor: 'Banco X',
      titular_cheque: 'Empresa SA',
      fecha_emision_cheque: '2026-10-05',
      cuenta_bancaria_id: 'cuenta-1',
    };
    const det = (extra: object) =>
      ({ cuenta_pagar_id: 'c', medio_pago_id: 'm', monto: 1, ...extra }) as OrdenPagoProveedorDetalleDto;

    it('cheque completo pasa; falta cada dato → DATOS_MEDIO_INCOMPLETOS con campo y linea', () => {
      expect(() => validarDatosMedio(det(chequeCompleto), CHEQUE, 1)).not.toThrow();
      for (const campo of [
        'numero_cheque',
        'banco_emisor',
        'titular_cheque',
        'fecha_emision_cheque',
        'cuenta_bancaria_id',
      ]) {
        const e = errorDe(() =>
          validarDatosMedio(
            det({ ...chequeCompleto, [campo]: campo === 'cuenta_bancaria_id' ? undefined : '   ' }),
            CHEQUE,
            3,
          ),
        );
        expect(e).toMatchObject({ status: 400, codigo: 'DATOS_MEDIO_INCOMPLETOS', campo, linea: 3 });
        expect(String(e.message)).toContain('3');
      }
    });

    it('transferencia y depósito piden la cuenta', () => {
      expect(errorDe(() => validarDatosMedio(det({}), TRANSFERENCIA, 2))).toMatchObject({
        codigo: 'DATOS_MEDIO_INCOMPLETOS',
        campo: 'cuenta_bancaria_id',
        linea: 2,
      });
      expect(errorDe(() => validarDatosMedio(det({}), DEPOSITO, 1))).toMatchObject({ campo: 'cuenta_bancaria_id' });
      expect(() => validarDatosMedio(det({ cuenta_bancaria_id: 'x' }), TRANSFERENCIA, 1)).not.toThrow();
    });

    it('tarjeta pide tarjeta_descripcion y ultimos_4', () => {
      expect(errorDe(() => validarDatosMedio(det({ ultimos_4: '1234' }), TARJETA, 1))).toMatchObject({
        campo: 'tarjeta_descripcion',
      });
      expect(errorDe(() => validarDatosMedio(det({ tarjeta_descripcion: 'Visa' }), TARJETA, 1))).toMatchObject({
        campo: 'ultimos_4',
      });
      expect(() =>
        validarDatosMedio(det({ tarjeta_descripcion: 'Visa', ultimos_4: '1234' }), TARJETA, 1),
      ).not.toThrow();
    });

    it('medio sin caja (no_mueve_caja de la empresa o anticipo): no se pide la cuenta, el resto sí', () => {
      const chequeSinCaja = { ...CHEQUE, no_mueve_caja: true };
      expect(() =>
        validarDatosMedio(det({ ...chequeCompleto, cuenta_bancaria_id: undefined }), chequeSinCaja, 1),
      ).not.toThrow();
      expect(
        errorDe(() =>
          validarDatosMedio(
            det({ ...chequeCompleto, cuenta_bancaria_id: undefined, banco_emisor: '' }),
            chequeSinCaja,
            1,
          ),
        ),
      ).toMatchObject({
        campo: 'banco_emisor',
      });
      expect(() => validarDatosMedio(det({}), { ...TRANSFERENCIA, no_mueve_caja: true }, 1)).not.toThrow();
      expect(() => validarDatosMedio(det({}), { codigo: 11, descripcion: 'Pago por anticipo' }, 1)).not.toThrow();
    });

    it('efectivo y otros no piden nada', () => {
      expect(() => validarDatosMedio(det({}), { codigo: 1, descripcion: 'Efectivo' }, 1)).not.toThrow();
      expect(() => validarDatosMedio(det({}), { codigo: 22, descripcion: 'Otro' }, 1)).not.toThrow();
    });
  });

  it('observacionesTarjeta', () => {
    expect(observacionesTarjeta('Visa Itaú', '1234')).toBe('Tarjeta Visa Itaú ****1234');
    expect(observacionesTarjeta('  Visa ', ' 9876 ')).toBe('Tarjeta Visa ****9876');
  });

  describe('DTO de la línea (F1): tarjeta y cheque', () => {
    const errores = (extra: object) =>
      validateSync(
        plainToInstance(OrdenPagoProveedorDetalleDto, {
          cuenta_pagar_id: 'a1b2c3d4-0000-4000-8000-000000000001',
          medio_pago_id: 'a1b2c3d4-0000-4000-8000-000000000002',
          monto: 10,
          ...extra,
        }),
      ).map((e) => e.property);
    it('ultimos_4 son 4 dígitos y tarjeta_descripcion hasta 60', () => {
      expect(errores({ tarjeta_descripcion: 'Visa', ultimos_4: '1234' })).toEqual([]);
      expect(errores({ ultimos_4: '12a4' })).toEqual(['ultimos_4']);
      expect(errores({ ultimos_4: '12345' })).toEqual(['ultimos_4']);
      expect(errores({ tarjeta_descripcion: 'x'.repeat(61) })).toEqual(['tarjeta_descripcion']);
    });
    it('numero_cheque solo dígitos, hasta 30', () => {
      expect(errores({ numero_cheque: '0001234' })).toEqual([]);
      expect(errores({ numero_cheque: 'A-12' })).toEqual(['numero_cheque']);
      expect(errores({ numero_cheque: '1'.repeat(31) })).toEqual(['numero_cheque']);
    });
  });
});
