import {
  diferenciasContraReferencia,
  estadoLinea,
  estadoPorEjecucion,
  montoEnMonedaRequisicion,
  nivelesParaMonto,
  totalesRequisicion,
} from './reglas-requisicion';
import { TRAMOS_RECOMENDADOS } from './config-recomendada';

describe('totalesRequisicion', () => {
  it('precio arriba del costo: los dos totales suben', () => {
    expect(totalesRequisicion([{ cantidad: 2, precio: 150, costo_referencia: 100 }])).toEqual({
      total_estimado: 300,
      total_para_aprobacion: 300,
    });
  });
  it('precio abajo del costo: total_para_aprobacion usa el costo', () => {
    expect(totalesRequisicion([{ cantidad: 10, precio: 80, costo_referencia: 100 }])).toEqual({
      total_estimado: 800,
      total_para_aprobacion: 1000,
    });
  });
  it('producto sin costo (referencia 0): usa el precio', () => {
    expect(totalesRequisicion([{ cantidad: 3, precio: 50, costo_referencia: 0 }])).toEqual({
      total_estimado: 150,
      total_para_aprobacion: 150,
    });
  });
  it('ítem libre (referencia null): usa el precio y redondea a 2', () => {
    expect(totalesRequisicion([{ cantidad: 3, precio: 10.3333, costo_referencia: null }])).toEqual({
      total_estimado: 31,
      total_para_aprobacion: 31,
    });
  });
});

describe('nivelesParaMonto', () => {
  const n = (nivel: number, desde: number, hasta: number | null, activo = true) => ({
    nivel,
    monto_desde: desde,
    monto_hasta: hasta,
    activo,
  });
  const rec = [n(1, 0, 1000000), n(2, 1000001, null)];
  it('config vieja con hueco (desde = hasta + 1): 1000000.5 no lo cubre nadie', () => {
    expect(nivelesParaMonto(rec, 1000000).map((c) => c.nivel)).toEqual([1]);
    expect(nivelesParaMonto(rec, 1000000.5)).toEqual([]);
    expect(nivelesParaMonto(rec, 1000001).map((c) => c.nivel)).toEqual([2]);
  });
  it('recomendada nueva (con ,01): 1.000.000 → [1]; 1.000.000,50 → [2]; 1.000.000,01 → [2]; 5.000.000,01 → [3]; 50.000.000,01 → [4]', () => {
    const nueva = TRAMOS_RECOMENDADOS.map((t, i) => n(i + 1, t.monto_desde, t.monto_hasta));
    const nivelesDe = (monto: number) => nivelesParaMonto(nueva, monto).map((c) => c.nivel);
    expect(nivelesDe(1_000_000)).toEqual([1]);
    expect(nivelesDe(1_000_000.5)).toEqual([2]);
    expect(nivelesDe(1_000_000.01)).toEqual([2]);
    expect(nivelesDe(5_000_000.01)).toEqual([3]);
    expect(nivelesDe(50_000_000.01)).toEqual([4]);
    // Sin huecos: ningún total entre 0 y el infinito queda sin nivel (a céntimos).
    for (const monto of [0, 0.01, 999_999.99, 5_000_000, 50_000_000, 99_999_999.99]) expect(nivelesDe(monto)).toHaveLength(1);
  });
  it('superpuestos: dos niveles, ordenados', () => {
    expect(nivelesParaMonto([n(2, 500, null), n(1, 0, 1000)], 700).map((c) => c.nivel)).toEqual([1, 2]);
  });
  it('ignora los inactivos', () => {
    expect(nivelesParaMonto([n(1, 0, null, false), n(2, 0, null)], 10).map((c) => c.nivel)).toEqual([2]);
  });
});

describe('montoEnMonedaRequisicion', () => {
  it('PYG queda igual', () => expect(montoEnMonedaRequisicion(123456.78, 'PYG', 7300)).toBe(123456.78));
  it('USD a 7300', () => expect(montoEnMonedaRequisicion(10.5, 'USD', 7300)).toBe(76650));
});

describe('estados por ejecución', () => {
  it('estadoLinea', () => {
    expect(estadoLinea(10, 0)).toBe('pendiente');
    expect(estadoLinea(10, 4)).toBe('ejecutada_parcial');
    expect(estadoLinea(10, 10)).toBe('ejecutada_total');
    expect(estadoLinea(10, 12)).toBe('ejecutada_total');
  });
  it('estadoPorEjecucion', () => {
    const l = (s: number, e: number) => ({ cantidad_solicitada: s, cantidad_ejecutada: e });
    expect(estadoPorEjecucion([l(1, 0), l(2, 0)])).toBe('aprobada');
    expect(estadoPorEjecucion([l(1, 1), l(2, 0)])).toBe('ejecutada_parcial');
    expect(estadoPorEjecucion([l(1, 0), l(2, 1)])).toBe('ejecutada_parcial');
    expect(estadoPorEjecucion([l(1, 1), l(2, 2)])).toBe('ejecutada_total');
  });
});

describe('diferenciasContraReferencia', () => {
  it('solo productos con precio distinto de la referencia', () => {
    const r = diferenciasContraReferencia([
      { id: 'a', cantidad: 2, precio: 120, costo_referencia: 100 },
      { id: 'b', cantidad: 1, precio: 100, costo_referencia: 100 },
      { id: 'c', cantidad: 1, precio: 50, costo_referencia: null },
      { id: 'd', cantidad: 4, precio: 90, costo_referencia: 100 },
    ]);
    expect(r.lineas).toEqual([
      { id: 'a', precio: 120, referencia: 100, diferencia: 20, porcentaje: 20 },
      { id: 'd', precio: 90, referencia: 100, diferencia: -10, porcentaje: -10 },
    ]);
    expect(r.suma).toBe(0);
  });
  it('excluye referencia 0, negativa o null (no divide por 0)', () => {
    const r = diferenciasContraReferencia([
      { id: 'a', cantidad: 1, precio: 50, costo_referencia: 0 },
      { id: 'b', cantidad: 1, precio: 50, costo_referencia: -1 },
      { id: 'c', cantidad: 1, precio: 50, costo_referencia: null },
    ]);
    expect(r).toEqual({ lineas: [], suma: 0 });
  });
  it('porcentaje no entero y suma distinta de cero', () => {
    const r = diferenciasContraReferencia([{ id: 'a', cantidad: 3, precio: 110, costo_referencia: 70 }]);
    expect(r.lineas[0]).toEqual({ id: 'a', precio: 110, referencia: 70, diferencia: 40, porcentaje: 57.14 });
    expect(r.suma).toBe(120);
  });
  it('excluye una diferencia menor a un centavo', () => {
    expect(diferenciasContraReferencia([{ id: 'a', cantidad: 1, precio: 100.004, costo_referencia: 100 }])).toEqual({
      lineas: [],
      suma: 0,
    });
  });
  it('redondeo simétrico: negativo con .5 se aleja de cero', () => {
    const pos = diferenciasContraReferencia([{ id: 'a', cantidad: 1, precio: 100.125, costo_referencia: 100 }]);
    const neg = diferenciasContraReferencia([{ id: 'a', cantidad: 1, precio: 99.875, costo_referencia: 100 }]);
    expect(pos.lineas[0].diferencia).toBe(0.13);
    expect(neg.lineas[0].diferencia).toBe(-0.13);
  });
});
