import { categoriaAplicaA, requiereAprobacion, validarCategoriasMovimiento } from './reglas-movimiento';

const EMP = 'emp-1';
const cat = (o: Partial<{ tipo: string | null; activo: boolean; empresa_id: string | null; is_sistema: boolean }> = {}) => ({
  tipo: 'AMBOS' as string | null,
  activo: true,
  empresa_id: EMP as string | null,
  is_sistema: false,
  ...o,
});
const catalogo = (o: Record<string, ReturnType<typeof cat>> = { c1: cat() }) => new Map(Object.entries(o));
const mov = (o: Partial<Parameters<typeof validarCategoriasMovimiento>[0]> = {}) => ({
  monto: 1000,
  tipo: 'INGRESO' as const,
  categorias: [{ categoria_id: 'c1', monto: 1000 }],
  ...o,
});
const falla = (m: Parameters<typeof validarCategoriasMovimiento>[0], c = catalogo()) => {
  try {
    validarCategoriasMovimiento(m, c, EMP);
  } catch (e: any) {
    return e.getResponse();
  }
  throw new Error('no lanzó');
};

describe('categoriaAplicaA', () => {
  it.each([
    [null, 'INGRESO', true],
    ['INGRESO', 'INGRESO', true],
    ['AMBOS', 'EGRESO', true],
    ['EGRESO', 'INGRESO', false],
    ['TRANSFERENCIA', 'EGRESO', false],
  ] as const)('tipo %s en un %s → %s', (tipo, en, esperado) => {
    expect(categoriaAplicaA({ tipo }, en)).toBe(esperado);
  });
});

describe('validarCategoriasMovimiento', () => {
  it('un movimiento sano no lanza', () => {
    expect(() => validarCategoriasMovimiento(mov(), catalogo(), EMP)).not.toThrow();
  });
  it('monto 0 → MONTO_INVALIDO en monto', () => {
    expect(falla(mov({ monto: 0 }))).toMatchObject({ codigo: 'MONTO_INVALIDO', campo: 'monto' });
  });
  it('sin categorías → CATEGORIAS_VACIAS', () => {
    expect(falla(mov({ categorias: [] }))).toMatchObject({ codigo: 'CATEGORIAS_VACIAS', campo: 'categorias' });
  });
  it('una categoría con monto 0 → MONTO_INVALIDO en categorias.0.monto', () => {
    expect(falla(mov({ categorias: [{ categoria_id: 'c1', monto: 0 }] }))).toMatchObject({ codigo: 'MONTO_INVALIDO', campo: 'categorias.0.monto' });
  });
  it('categoría de otra empresa → CATEGORIA_INVALIDA; del sistema pasa; inactiva y que no aplica, no', () => {
    expect(falla(mov(), catalogo({ c1: cat({ empresa_id: 'otra' }) }))).toMatchObject({ codigo: 'CATEGORIA_INVALIDA', campo: 'categorias.0.categoria_id' });
    expect(() => validarCategoriasMovimiento(mov(), catalogo({ c1: cat({ empresa_id: null, is_sistema: true }) }), EMP)).not.toThrow();
    expect(falla(mov(), catalogo({ c1: cat({ activo: false }) }))).toMatchObject({ codigo: 'CATEGORIA_INVALIDA' });
    expect(falla(mov(), catalogo({ c1: cat({ tipo: 'EGRESO' }) }))).toMatchObject({ codigo: 'CATEGORIA_INVALIDA' });
    expect(falla(mov(), catalogo({}))).toMatchObject({ codigo: 'CATEGORIA_INVALIDA' });
  });
  it('empresa_id null sin ser del sistema no sirve', () => {
    expect(falla(mov(), catalogo({ c1: cat({ empresa_id: null, is_sistema: false }) }))).toMatchObject({ codigo: 'CATEGORIA_INVALIDA' });
  });
  it('105.000.000 con un detalle de 10.500.000 → CATEGORIAS_NO_SUMAN con diferencia 94500000 (Kety)', () => {
    expect(falla(mov({ monto: 105_000_000, categorias: [{ categoria_id: 'c1', monto: 10_500_000 }] }))).toMatchObject({
      codigo: 'CATEGORIAS_NO_SUMAN',
      campo: 'categorias',
      diferencia: 94_500_000,
    });
  });
  it('17.500 con 175.000 → diferencia -157500', () => {
    expect(falla(mov({ monto: 17_500, categorias: [{ categoria_id: 'c1', monto: 175_000 }] }))).toMatchObject({ diferencia: -157_500 });
  });
  it('100,10 con 100,05 + 0,05 pasa (centavos)', () => {
    expect(() =>
      validarCategoriasMovimiento(
        mov({
          monto: 100.1,
          categorias: [
            { categoria_id: 'c1', monto: 100.05 },
            { categoria_id: 'c1', monto: 0.05 },
          ],
        }),
        catalogo(),
        EMP,
      ),
    ).not.toThrow();
  });
});

describe('requiereAprobacion', () => {
  it('umbral 0 → false; debajo → false; igual o encima → true', () => {
    expect(requiereAprobacion(5_000_000, 0)).toBe(false);
    expect(requiereAprobacion(999, 1000)).toBe(false);
    expect(requiereAprobacion(1000, 1000)).toBe(true);
  });
  it('monto en base desconocido (sin cotización) con umbral → true; sin umbral → false', () => {
    expect(requiereAprobacion(null, 1000)).toBe(true);
    expect(requiereAprobacion(null, 0)).toBe(false);
  });
});
