import { ListaPreciosService } from './lista-precios.service';

/**
 * Red de resolución de precio (Stock P1): lo que cobra una venta, fijado contra el motor
 * antes de tocarlo. El mock de Prisma interpreta el `where` real y compara las columnas
 * `@db.Date` por día UTC, que es lo que hace Prisma: trunca el parámetro al día UTC
 * (verificado corriendo Prisma: `fecha_inicio >= 2026-05-12T12:00Z` da verdadero para la
 * fila del 12).
 */
const diaUtc = (f: Date | string) => new Date(f).toISOString().slice(0, 10);

/** Compara una columna `@db.Date` contra una condición de Prisma, por día UTC. */
const cumpleFecha = (columna: Date | null, cond: any): boolean => {
  if (cond === null) return columna === null;
  if (columna === null) return false;
  const c = diaUtc(columna);
  if (cond.lte !== undefined && !(c <= diaUtc(cond.lte))) return false;
  if (cond.gte !== undefined && !(c >= diaUtc(cond.gte))) return false;
  if (cond.lt !== undefined && !(c < diaUtc(cond.lt))) return false;
  if (cond.gt !== undefined && !(c > diaUtc(cond.gt))) return false;
  return true;
};

const cumpleVigencia = (fila: any, where: any): boolean => {
  if (where.fecha_inicio && !cumpleFecha(fila.fecha_inicio, where.fecha_inicio)) return false;
  if (where.OR && !where.OR.some((o: any) => cumpleFecha(fila.fecha_fin, o.fecha_fin))) return false;
  return true;
};

const lista = (extra: any = {}) => ({
  id: 'l-gen',
  empresa_id: 'e1',
  codigo: 'GEN',
  nombre: 'General',
  moneda: 'PYG',
  prioridad: 1,
  tipo_aplicacion: 'general',
  activa: true,
  fecha_inicio: new Date('2020-01-01'),
  fecha_fin: null,
  fecha_creacion: new Date('2020-01-01T10:00:00Z'),
  aplica_descuento_general: false,
  descuento_porcentaje: 0,
  aplica_recargo_general: false,
  recargo_porcentaje: 0,
  redondeo_activo: false,
  redondeo_tipo: 'normal',
  redondeo_decimales: 0,
  ...extra,
});

const fila = (listaId: string, precio: number, productoId = 'P') => ({
  id: `f-${listaId}`,
  lista_precios_id: listaId,
  producto_id: productoId,
  precio_base: precio,
  descuento_porcentaje: 0,
  recargo_porcentaje: 0,
  precio_minimo: null,
  precio_maximo: null,
  descuento_maximo_pct: null,
  permite_cuotas: true,
  cuotas_maximas: 12,
});

const asignacion = (extra: any) => ({
  lista_precios_id: 'l-cli',
  tipo_entidad: 'cliente',
  entidad_id: null,
  zona_id: null,
  activa: true,
  fecha_inicio: new Date('2020-01-01'),
  fecha_fin: null,
  ...extra,
});

/** Prisma de mentira que interpreta el `where` y el `orderBy` reales del motor. */
const prismaDe = (d: { listas?: any[]; filas?: any[]; productos?: any[]; clientes?: any[]; asignaciones?: any[]; principal?: string; cotizaciones?: any[] }) => {
  const listas = d.listas ?? [];
  const filas = d.filas ?? [];
  const productos = d.productos ?? [{ id: 'P', precio: 65000, precio_costo: 44880 }];
  const clientes = d.clientes ?? [];
  const asignaciones = d.asignaciones ?? [];
  const ordenar = (arr: any[], orderBy: any[] = []) =>
    [...arr].sort((a, b) => {
      for (const o of orderBy) {
        const [campo, dir] = Object.entries(o)[0] as [string, string];
        const va = a[campo] instanceof Date ? a[campo].getTime() : a[campo];
        const vb = b[campo] instanceof Date ? b[campo].getTime() : b[campo];
        if (va !== vb) return (va < vb ? -1 : 1) * (dir === 'asc' ? 1 : -1);
      }
      return 0;
    });
  return {
    clientes: {
      findFirst: jest.fn(({ where }: any) => Promise.resolve(clientes.find((c) => c.id === where.id) ?? null)),
      findMany: jest.fn(() => Promise.resolve(clientes)),
    },
    lista_precios_asignaciones: {
      findMany: jest.fn(({ where }: any) =>
        Promise.resolve(
          asignaciones.filter(
            (a) =>
              a.activa === where.activa &&
              a.tipo_entidad === where.tipo_entidad &&
              (typeof where.entidad_id !== 'string' || a.entidad_id === where.entidad_id) &&
              (typeof where.zona_id !== 'string' || a.zona_id === where.zona_id) &&
              cumpleVigencia(a, where),
          ),
        ),
      ),
    },
    lista_precios: {
      findMany: jest.fn(({ where, orderBy }: any) =>
        Promise.resolve(
          ordenar(
            listas.filter(
              (l) =>
                l.empresa_id === where.empresa_id &&
                (where.activa === undefined || l.activa === where.activa) &&
                (!where.moneda || l.moneda === where.moneda) &&
                (!where.tipo_aplicacion || l.tipo_aplicacion === where.tipo_aplicacion) &&
                (!where.id?.in || where.id.in.includes(l.id)) &&
                cumpleVigencia(l, where),
            ),
            orderBy,
          ),
        ),
      ),
    },
    productos: {
      findMany: jest.fn(({ where }: any) => Promise.resolve(productos.filter((p) => where.id.in.includes(p.id)))),
    },
    lista_precios_productos: {
      findMany: jest.fn(({ where }: any) => Promise.resolve(filas.filter((f) => where.producto_id.in.includes(f.producto_id)))),
    },
    empresa_monedas: { findFirst: jest.fn(() => Promise.resolve({ moneda: { codigo: d.principal ?? 'PYG' } })) },
    cotizacion_moneda: {
      findFirst: jest.fn(({ where }: any) => {
        const candidatas = (d.cotizaciones ?? []).filter((c) => c.codigo === where.moneda.codigo && cumpleFecha(c.fecha, where.fecha));
        const ultima = [...candidatas].sort((a, b) => b.fecha.getTime() - a.fecha.getTime())[0];
        return Promise.resolve(ultima ? { cotizacion_venta: ultima.cotizacion_venta } : null);
      }),
    },
  };
};

const servicio = (d: Parameters<typeof prismaDe>[0]) => {
  const s = Object.create(ListaPreciosService.prototype) as ListaPreciosService;
  (s as any).prisma = prismaDe(d);
  return s;
};

const precio = async (d: Parameters<typeof prismaDe>[0], extra: { clienteId?: string; moneda?: string } = {}) => {
  const r = await servicio(d).obtenerPreciosProductosBatch({ productoIds: ['P'], empresaId: 'e1', ...extra });
  return r.P;
};

describe('resolución de precio de venta', () => {
  it('sin lista: precio del producto y listaAplicada null', async () => {
    const r = await precio({});
    expect(r.precioFinal).toBe(65000);
    expect(r.listaAplicada).toBeNull();
    expect(r.precioBaseGobernado).toBe(false);
  });

  it('la lista propia sin el producto aplica su ajuste general', async () => {
    const r = await precio(
      {
        listas: [lista({ id: 'l-pro', codigo: 'LP002', aplica_recargo_general: true, recargo_porcentaje: 25 })],
        clientes: [{ id: 'c1', lista_precios_id: 'l-pro', zona_id: null }],
      },
      { clienteId: 'c1' },
    );
    expect(r.precioFinal).toBe(81250);
    expect(r.listaAplicada.codigo).toBe('LP002');
  });

  it('la General con el producto da su precio', async () => {
    const r = await precio({ listas: [lista()], filas: [fila('l-gen', 70000)] });
    expect(r.precioFinal).toBe(70000);
    expect(r.precioBaseGobernado).toBe(true);
  });

  it('la General sin el producto no aplica su ajuste', async () => {
    const r = await precio({ listas: [lista({ aplica_recargo_general: true, recargo_porcentaje: 50 })] });
    expect(r.precioFinal).toBe(65000);
    expect(r.listaAplicada).toBeNull();
  });

  it('la lista del cliente gana aunque su prioridad sea peor', async () => {
    const r = await precio(
      {
        listas: [lista(), lista({ id: 'l-cli', codigo: 'CLI', tipo_aplicacion: 'cliente', prioridad: 9 })],
        filas: [fila('l-gen', 70000), fila('l-cli', 60000)],
        clientes: [{ id: 'c1', lista_precios_id: null, zona_id: null }],
        asignaciones: [asignacion({ entidad_id: 'c1' })],
      },
      { clienteId: 'c1' },
    );
    expect(r.precioFinal).toBe(60000);
    expect(r.listaAplicada.codigo).toBe('CLI');
  });

  it('por zona: el de la zona recibe la lista, el de otra zona no', async () => {
    const datos = {
      listas: [lista(), lista({ id: 'l-zon', codigo: 'ZON', tipo_aplicacion: 'zona', prioridad: 9 })],
      filas: [fila('l-gen', 70000), fila('l-zon', 123000)],
      clientes: [
        { id: 'c-norte', lista_precios_id: null, zona_id: 'z-norte' },
        { id: 'c-sur', lista_precios_id: null, zona_id: 'z-sur' },
      ],
      asignaciones: [asignacion({ lista_precios_id: 'l-zon', tipo_entidad: 'zona', zona_id: 'z-norte' })],
    };
    expect((await precio(datos, { clienteId: 'c-norte' })).precioFinal).toBe(123000);
    expect((await precio(datos, { clienteId: 'c-sur' })).precioFinal).toBe(70000);
  });

  it('otra moneda: USD ve la lista en USD, PYG no, y sin lista en USD el precio es 0', async () => {
    const datos = { listas: [lista({ id: 'l-usd', codigo: 'USD1', moneda: 'USD' })], filas: [fila('l-usd', 12.5)] };
    const enUsd = await precio(datos, { moneda: 'USD' });
    expect(enUsd.precioFinal).toBe(12.5);
    expect(enUsd.moneda).toBe('USD');
    expect((await precio(datos, { moneda: 'PYG' })).precioFinal).toBe(65000);
    const sinLista = await precio({ listas: [] }, { moneda: 'USD' });
    expect(sinLista.precioFinal).toBe(0);
    expect(sinLista.listaAplicada).toBeNull();
  });

  it('borrador: activa false no aplica', async () => {
    const r = await precio({ listas: [lista({ activa: false })], filas: [fila('l-gen', 50000)] });
    expect(r.precioFinal).toBe(65000);
  });

  describe('vigencia, de día', () => {
    beforeEach(() => jest.useFakeTimers({ now: new Date('2026-11-05T15:00:00Z') }));
    afterEach(() => jest.useRealTimers());

    it('empieza mañana no aplica; terminó ayer no aplica; termina hoy aplica', async () => {
      const f = [fila('l-gen', 70000)];
      expect((await precio({ listas: [lista({ fecha_inicio: new Date('2026-11-06') })], filas: f })).precioFinal).toBe(65000);
      expect((await precio({ listas: [lista({ fecha_fin: new Date('2026-11-04') })], filas: f })).precioFinal).toBe(65000);
      expect((await precio({ listas: [lista({ fecha_fin: new Date('2026-11-05') })], filas: f })).precioFinal).toBe(70000);
    });
  });

  it('a distinta prioridad gana la menor; a igual, la más antigua', async () => {
    const nueva = new Date('2025-01-01T10:00:00Z');
    const vieja = new Date('2021-01-01T10:00:00Z');
    const distinta = await precio({
      listas: [lista({ id: 'a', codigo: 'P2', prioridad: 2, fecha_creacion: vieja }), lista({ id: 'b', codigo: 'P1', prioridad: 1, fecha_creacion: nueva })],
      filas: [fila('a', 80000), fila('b', 70000)],
    });
    expect(distinta.listaAplicada.codigo).toBe('P1');
    const empate = await precio({
      listas: [lista({ id: 'a', codigo: 'NUEVA', prioridad: 1, fecha_creacion: nueva }), lista({ id: 'b', codigo: 'VIEJA', prioridad: 1, fecha_creacion: vieja })],
      filas: [fila('a', 80000), fila('b', 70000)],
    });
    expect(empate.listaAplicada.codigo).toBe('VIEJA');
  });

  it('la forma de batch no cambia', async () => {
    const r = await servicio({ listas: [lista()], filas: [fila('l-gen', 70000)] }).obtenerPreciosProductosBatch({ productoIds: ['P'], empresaId: 'e1' });
    expect(Object.keys(r.P).sort()).toEqual([
      'cuotasMaximas',
      'descuentoGeneral',
      'descuentoMaximoPct',
      'descuentos',
      'listaAplicada',
      'moneda',
      'permiteCuotas',
      'precioBase',
      'precioBaseGobernado',
      'precioCosto',
      'precioFinal',
      'precioMaximo',
      'precioMinimo',
      'productoId',
      'recargoGeneral',
      'recargos',
      'topeDescuentoPct',
    ]);
    expect(Object.keys(r.P.listaAplicada).sort()).toEqual(['codigo', 'id', 'moneda', 'nombre']);
  });

  it('sin lista, batch trae las mismas claves', async () => {
    const r = await precio({});
    expect(Object.keys(r).sort()).toEqual(
      ['cuotasMaximas', 'descuentoGeneral', 'descuentoMaximoPct', 'descuentos', 'listaAplicada', 'moneda', 'permiteCuotas', 'precioBase', 'precioBaseGobernado', 'precioCosto', 'precioFinal', 'precioMaximo', 'precioMinimo', 'productoId', 'recargoGeneral', 'recargos', 'topeDescuentoPct'].sort(),
    );
  });

  describe('a las 22:00 de Asunción (01:00 UTC del día siguiente)', () => {
    beforeEach(() => jest.useFakeTimers({ now: new Date('2026-11-06T01:00:00Z') }));
    afterEach(() => jest.useRealTimers());

    it('a las 22:00 de Asunción, una lista que termina hoy sigue aplicando', async () => {
      const r = await precio({ listas: [lista({ fecha_fin: new Date('2026-11-05') })], filas: [fila('l-gen', 70000)] });
      expect(r.precioFinal).toBe(70000);
    });

    it('a las 22:00 de Asunción, una lista que empieza mañana todavía no aplica', async () => {
      const r = await precio({ listas: [lista({ fecha_inicio: new Date('2026-11-06') })], filas: [fila('l-gen', 70000)] });
      expect(r.precioFinal).toBe(65000);
    });

    it('a las 22:00 de Asunción, una asignación que termina hoy sigue aplicando', async () => {
      const r = await precio(
        {
          listas: [lista({ id: 'l-cli', codigo: 'CLI', tipo_aplicacion: 'cliente' })],
          filas: [fila('l-cli', 60000)],
          clientes: [{ id: 'c1', lista_precios_id: null, zona_id: null }],
          asignaciones: [asignacion({ entidad_id: 'c1', fecha_fin: new Date('2026-11-05') })],
        },
        { clienteId: 'c1' },
      );
      expect(r.precioFinal).toBe(60000);
    });

    it('a las 22:00 de Asunción, el catálogo sin conexión ve la lista propia que termina hoy', async () => {
      const r = await servicio({
        listas: [lista({ id: 'l-cli', tipo_aplicacion: 'cliente', fecha_fin: new Date('2026-11-05') })],
        clientes: [{ id: 'c1', lista_precios_id: 'l-cli', zona_id: null }],
      }).listasPropiasPorCliente('e1', 'PYG');
      expect(Object.fromEntries(r)).toEqual({ c1: ['l-cli'] });
    });

    it('a las 22:00 de Asunción, el catálogo sin conexión no ve la lista propia que empieza mañana', async () => {
      const r = await servicio({
        listas: [lista({ id: 'l-cli', tipo_aplicacion: 'cliente', fecha_inicio: new Date('2026-11-06') })],
        clientes: [{ id: 'c1', lista_precios_id: 'l-cli', zona_id: null }],
      }).listasPropiasPorCliente('e1', 'PYG');
      expect(Object.fromEntries(r)).toEqual({});
    });

    it('a las 22:00 de Asunción, no se toma la cotización de mañana', async () => {
      const s = servicio({
        cotizaciones: [
          { codigo: 'USD', fecha: new Date('2026-11-05'), cotizacion_venta: 7000 },
          { codigo: 'USD', fecha: new Date('2026-11-06'), cotizacion_venta: 8000 },
        ],
      });
      await expect(s.ultimaCotizacionVenta('e1', 'USD')).resolves.toBe(7000);
    });
  });
});
