import { HttpException } from '@nestjs/common';
import { ComprasService } from '../compras.service';
import { CompraBorradoresService, MAX_BYTES_DATOS_BORRADOR } from './compra-borradores.service';

const EMP = 'emp-1';
const USR = 'usr-1';

/** Cuerpo y status del error HTTP que tira la promesa. */
const errorDe = async (p: Promise<unknown>) => {
  const e = await p.then(
    () => null,
    (err) => err,
  );
  expect(e).toBeInstanceOf(HttpException);
  return { status: (e as HttpException).getStatus(), cuerpo: (e as HttpException).getResponse() as any };
};

const prismaFalso = () => ({
  compra_borradores: {
    findMany: jest.fn().mockResolvedValue([]),
    findFirst: jest.fn().mockResolvedValue(null),
    create: jest.fn(async ({ data }: any) => ({ id: 'b-nuevo', ...data, moneda: null })),
    updateMany: jest.fn().mockResolvedValue({ count: 0 }),
    deleteMany: jest.fn().mockResolvedValue({ count: 0 }),
  },
  proveedores: { findFirst: jest.fn().mockResolvedValue(null) },
  productos: { findMany: jest.fn().mockResolvedValue([]) },
  orden_compra_cab: { findFirst: jest.fn().mockResolvedValue(null) },
  empresa_monedas: { findFirst: jest.fn().mockResolvedValue({ id: 'em-1' }) },
});

// Ids con forma real: los avisos solo consultan UUIDs válidos.
const PROV = '11111111-1111-4111-8111-111111111111';
const OC = '22222222-2222-4222-8222-222222222222';
const P_OK = '33333333-3333-4333-8333-333333333301';
const P_INACTIVO = '33333333-3333-4333-8333-333333333302';
const P_BORRADO = '33333333-3333-4333-8333-333333333303';
const P_OTRA_EMPRESA = '33333333-3333-4333-8333-333333333304';

const borradorGuardado = (datos: unknown = {}) => ({
  id: 'b-1',
  proveedor_nombre: 'ACME SA',
  numero_comprobante: '001-001-0000123',
  total: '150000.0000',
  moneda_id: 'mon-1',
  moneda: { id: 'mon-1', codigo: 'PYG' },
  created_at: new Date('2026-10-21T10:00:00.000Z'),
  updated_at: new Date('2026-10-21T10:05:00.123Z'),
  datos,
});

describe('CompraBorradoresService', () => {
  it('listar trae solo los del usuario y la empresa, sin datos, con moneda.codigo', async () => {
    const prisma = prismaFalso();
    await new CompraBorradoresService(prisma as any).listar(EMP, USR);

    const args = prisma.compra_borradores.findMany.mock.calls[0][0];
    expect(args.where).toEqual({ empresa_id: EMP, usuario_id: USR });
    expect(args.select.datos).toBeUndefined();
    expect(args.select.moneda).toEqual({ select: { id: true, codigo: true } });
    expect(args.orderBy).toEqual({ updated_at: 'desc' });
    // Tope de la lista (M9 de la revisión final): los 50 más recientes.
    expect(args.take).toBe(50);
  });

  it.each([
    ['otro usuario', EMP, 'usr-2'],
    ['otra empresa', 'emp-2', USR],
  ])('obtener de %s → 404 BORRADOR_NO_ENCONTRADO', async (_caso, empresa, usuario) => {
    const prisma = prismaFalso();
    const { status, cuerpo } = await errorDe(new CompraBorradoresService(prisma as any).obtener('b-1', empresa, usuario));

    expect(status).toBe(404);
    expect(cuerpo.codigo).toBe('BORRADOR_NO_ENCONTRADO');
    expect(prisma.compra_borradores.findFirst.mock.calls[0][0].where).toEqual({
      id: 'b-1',
      empresa_id: empresa,
      usuario_id: usuario,
    });
  });

  it('descartar ajeno → 404 BORRADOR_NO_ENCONTRADO; propio → { id }', async () => {
    const prisma = prismaFalso();
    const service = new CompraBorradoresService(prisma as any);
    const { status, cuerpo } = await errorDe(service.descartar('b-1', EMP, 'usr-2'));
    expect(status).toBe(404);
    expect(cuerpo.codigo).toBe('BORRADOR_NO_ENCONTRADO');
    expect(prisma.compra_borradores.deleteMany.mock.calls[0][0].where).toEqual({ id: 'b-1', empresa_id: EMP, usuario_id: 'usr-2' });

    prisma.compra_borradores.deleteMany.mockResolvedValueOnce({ count: 1 });
    await expect(service.descartar('b-1', EMP, USR)).resolves.toEqual({ id: 'b-1' });
  });

  it('crear guarda empresa y usuario del token y el resumen', async () => {
    const prisma = prismaFalso();
    const datos = { cabecera: { proveedor_id: 'prov-1' }, ui: { paso: 2 } };
    await new CompraBorradoresService(prisma as any).crear(
      { datos, proveedor_nombre: 'ACME SA', total: 1000, moneda_id: 'mon-1' },
      EMP,
      USR,
    );

    const { data, select } = prisma.compra_borradores.create.mock.calls[0][0];
    expect(data).toMatchObject({
      empresa_id: EMP,
      usuario_id: USR,
      datos,
      proveedor_nombre: 'ACME SA',
      numero_comprobante: null,
      total: 1000,
      moneda_id: 'mon-1',
    });
    expect(data.updated_at).toBeInstanceOf(Date);
    expect(select.moneda).toEqual({ select: { id: true, codigo: true } });
  });

  it('actualizar con version vieja → 409 DATOS_CAMBIADOS', async () => {
    const prisma = prismaFalso();
    prisma.compra_borradores.findFirst.mockResolvedValue(borradorGuardado());
    const version = '2026-10-21T10:00:00.000Z';
    const { status, cuerpo } = await errorDe(
      new CompraBorradoresService(prisma as any).actualizar('b-1', { datos: {}, version }, EMP, USR),
    );

    expect(status).toBe(409);
    expect(cuerpo.codigo).toBe('DATOS_CAMBIADOS');
    expect(prisma.compra_borradores.updateMany.mock.calls[0][0].where).toEqual({
      id: 'b-1',
      empresa_id: EMP,
      usuario_id: USR,
      updated_at: new Date(version),
    });
  });

  it('actualizar un borrador ajeno → 404, no 409', async () => {
    const prisma = prismaFalso();
    const { status, cuerpo } = await errorDe(
      new CompraBorradoresService(prisma as any).actualizar('b-1', { datos: {}, version: '2026-10-21T10:00:00.000Z' }, EMP, 'usr-2'),
    );
    expect(status).toBe(404);
    expect(cuerpo.codigo).toBe('BORRADOR_NO_ENCONTRADO');
  });

  it('actualizar con la version vigente guarda y devuelve el borrador nuevo', async () => {
    const prisma = prismaFalso();
    prisma.compra_borradores.updateMany.mockResolvedValue({ count: 1 });
    prisma.compra_borradores.findFirst.mockResolvedValue(borradorGuardado({ ui: {} }));
    const res = await new CompraBorradoresService(prisma as any).actualizar(
      'b-1',
      { datos: { ui: {} }, numero_comprobante: '001-001-0000123', version: '2026-10-21T10:05:00.123Z' },
      EMP,
      USR,
    );
    expect(res.id).toBe('b-1');
    const { data } = prisma.compra_borradores.updateMany.mock.calls[0][0];
    expect(data.numero_comprobante).toBe('001-001-0000123');
    expect(data.updated_at).toBeInstanceOf(Date);
  });

  it('actualizar sin version → 400 CAMPO_REQUERIDO en version, sin guardar', async () => {
    const prisma = prismaFalso();
    const { status, cuerpo } = await errorDe(new CompraBorradoresService(prisma as any).actualizar('b-1', { datos: {} }, EMP, USR));
    expect(status).toBe(400);
    expect(cuerpo).toMatchObject({ codigo: 'CAMPO_REQUERIDO', campo: 'version' });
    expect(prisma.compra_borradores.updateMany).not.toHaveBeenCalled();
  });

  it('datos de 300 KB → 400 BORRADOR_MUY_GRANDE (al crear y al actualizar)', async () => {
    const prisma = prismaFalso();
    const service = new CompraBorradoresService(prisma as any);
    const datos = { ui: { nota: 'x'.repeat(300 * 1024) } };
    expect(Buffer.byteLength(JSON.stringify(datos))).toBeGreaterThan(MAX_BYTES_DATOS_BORRADOR);

    const alCrear = await errorDe(service.crear({ datos }, EMP, USR));
    expect(alCrear.status).toBe(400);
    expect(alCrear.cuerpo.codigo).toBe('BORRADOR_MUY_GRANDE');
    const alActualizar = await errorDe(service.actualizar('b-1', { datos, version: '2026-10-21T10:00:00.000Z' }, EMP, USR));
    expect(alActualizar.cuerpo.codigo).toBe('BORRADOR_MUY_GRANDE');
    expect(prisma.compra_borradores.create).not.toHaveBeenCalled();
    expect(prisma.compra_borradores.updateMany).not.toHaveBeenCalled();
  });

  it('obtener avisa PROVEEDOR_INACTIVO, PRODUCTO_INACTIVO con producto_id y OC_NO_FACTURABLE', async () => {
    const prisma = prismaFalso();
    prisma.compra_borradores.findFirst.mockResolvedValue(
      borradorGuardado({
        cabecera: { proveedor_id: PROV, orden_compra_id: OC },
        items: [{ producto_id: P_OK }, { producto_id: P_INACTIVO }, { producto_id: P_BORRADO }, { producto_id: P_OTRA_EMPRESA }],
      }),
    );
    prisma.proveedores.findFirst.mockResolvedValue({ activo: false });
    prisma.productos.findMany.mockResolvedValue([
      { id: P_OK, active: true, deleted: false },
      { id: P_INACTIVO, active: false, deleted: false },
      { id: P_BORRADO, active: true, deleted: true },
    ]);
    prisma.orden_compra_cab.findFirst.mockResolvedValue({ estado: 'completada', activo: true });

    const res = await new CompraBorradoresService(prisma as any).obtener('b-1', EMP, USR);

    expect(res.avisos.map((a) => [a.codigo, a.producto_id])).toEqual([
      ['PROVEEDOR_INACTIVO', undefined],
      ['PRODUCTO_INACTIVO', P_INACTIVO],
      ['PRODUCTO_INACTIVO', P_BORRADO],
      ['PRODUCTO_INACTIVO', P_OTRA_EMPRESA],
      ['OC_NO_FACTURABLE', undefined],
    ]);
    res.avisos.forEach((a) => expect(a.message).toEqual(expect.any(String)));
    expect(prisma.proveedores.findFirst.mock.calls[0][0].where).toEqual({ id: PROV, empresa_id: EMP });
    expect(prisma.productos.findMany.mock.calls[0][0].where.empresa_id).toBe(EMP);
    expect(prisma.orden_compra_cab.findFirst.mock.calls[0][0].where).toEqual({ id: OC, empresa_id: EMP });
    expect(res.datos).toBeDefined();
    expect(res.moneda).toEqual({ id: 'mon-1', codigo: 'PYG' });
  });

  it('obtener sin avisos cuando proveedor, productos y OC (parcial) siguen usables', async () => {
    const prisma = prismaFalso();
    prisma.compra_borradores.findFirst.mockResolvedValue(
      borradorGuardado({ cabecera: { proveedor_id: PROV, orden_compra_id: OC }, items: [{ producto_id: P_OK }] }),
    );
    prisma.proveedores.findFirst.mockResolvedValue({ activo: true });
    prisma.productos.findMany.mockResolvedValue([{ id: P_OK, active: true, deleted: false }]);
    prisma.orden_compra_cab.findFirst.mockResolvedValue({ estado: 'parcial', activo: true });

    await expect(new CompraBorradoresService(prisma as any).obtener('b-1', EMP, USR)).resolves.toMatchObject({ avisos: [] });
  });

  it('ids que no son UUID en datos se ignoran para los avisos: el borrador abre igual con sus datos', async () => {
    const prisma = prismaFalso();
    const datos = {
      cabecera: { proveedor_id: 'abc', orden_compra_id: 'oc-vieja' },
      items: [{ producto_id: 'no-es-uuid' }, { producto_id: P_INACTIVO }],
    };
    prisma.compra_borradores.findFirst.mockResolvedValue(borradorGuardado(datos));
    prisma.productos.findMany.mockResolvedValue([{ id: P_INACTIVO, active: false, deleted: false }]);

    const res = await new CompraBorradoresService(prisma as any).obtener('b-1', EMP, USR);

    expect(res.datos).toEqual(datos);
    expect(res.avisos).toEqual([expect.objectContaining({ codigo: 'PRODUCTO_INACTIVO', producto_id: P_INACTIVO })]);
    expect(prisma.proveedores.findFirst).not.toHaveBeenCalled();
    expect(prisma.orden_compra_cab.findFirst).not.toHaveBeenCalled();
    expect(prisma.productos.findMany.mock.calls[0][0].where.id).toEqual({ in: [P_INACTIVO] });
  });

  it.each([
    ['crear', (s: CompraBorradoresService) => s.crear({ datos: {}, moneda_id: 'mon-x' }, EMP, USR)],
    [
      'actualizar',
      (s: CompraBorradoresService) => s.actualizar('b-1', { datos: {}, moneda_id: 'mon-x', version: '2026-10-21T10:00:00.000Z' }, EMP, USR),
    ],
  ])('%s con una moneda que la empresa no tiene → 400 MONEDA_INVALIDA en moneda_id, sin escribir', async (_caso, llamar) => {
    const prisma = prismaFalso();
    prisma.empresa_monedas.findFirst.mockResolvedValue(null);
    const { status, cuerpo } = await errorDe(llamar(new CompraBorradoresService(prisma as any)));

    expect(status).toBe(400);
    expect(cuerpo).toMatchObject({ codigo: 'MONEDA_INVALIDA', campo: 'moneda_id' });
    expect(prisma.empresa_monedas.findFirst.mock.calls[0][0].where).toEqual({ empresa_id: EMP, moneda_id: 'mon-x', active: true });
    expect(prisma.compra_borradores.create).not.toHaveBeenCalled();
    expect(prisma.compra_borradores.updateMany).not.toHaveBeenCalled();
  });

  it('sin moneda_id no consulta empresa_monedas', async () => {
    const prisma = prismaFalso();
    await new CompraBorradoresService(prisma as any).crear({ datos: {} }, EMP, USR);
    expect(prisma.empresa_monedas.findFirst).not.toHaveBeenCalled();
  });

  it.each([
    ['vacíos', {}],
    ['con otra forma', { cabecera: 'texto', items: 'no-lista' }],
    ['con nulos', { cabecera: null, items: [null, 3, { producto_id: '' }] }],
  ])('datos sin cabecera ni items (%s) → sin avisos ni error', async (_caso, datos) => {
    const prisma = prismaFalso();
    prisma.compra_borradores.findFirst.mockResolvedValue(borradorGuardado(datos));

    await expect(new CompraBorradoresService(prisma as any).obtener('b-1', EMP, USR)).resolves.toMatchObject({ avisos: [] });
    expect(prisma.proveedores.findFirst).not.toHaveBeenCalled();
    expect(prisma.productos.findMany).not.toHaveBeenCalled();
    expect(prisma.orden_compra_cab.findFirst).not.toHaveBeenCalled();
  });
});

describe('ComprasService.create con borrador_id', () => {
  /**
   * Prisma con transacción de verdad para los borradores: lo que se borra dentro de `$transaction`
   * se confirma solo si el callback termina bien; si tira, se descarta (rollback).
   */
  type Fila = { id: string; empresa_id: string; usuario_id: string; updated_at?: Date };
  const propia = (f: Fila, where: any) =>
    f.id === where.id && f.empresa_id === where.empresa_id && f.usuario_id === where.usuario_id;
  const montar = (filas: Fila[]) => {
    // Como Postgres: el filtro por `updated_at` compara la versión exacta.
    const deleteManyDe = (lista: Fila[]) =>
      jest.fn(async ({ where }: any) => {
        const antes = lista.length;
        for (let i = lista.length - 1; i >= 0; i--) {
          const f = lista[i];
          const enVersion = !where.updated_at || f.updated_at?.getTime() === where.updated_at.getTime();
          if (propia(f, where) && enVersion) lista.splice(i, 1);
        }
        return { count: antes - lista.length };
      });
    const findFirstDe = (lista: Fila[]) =>
      jest.fn(async ({ where }: any) => lista.find((f) => propia(f, where)) ?? null);
    const tx: any = { compra_borradores: {}, compra_cab: { create: jest.fn() } };
    const prisma: any = {
      compra_borradores: { deleteMany: jest.fn() },
      compra_cab: { create: jest.fn() },
      $transaction: jest.fn(async (cb: (t: any) => Promise<unknown>) => {
        const enCurso = [...filas];
        tx.compra_borradores.deleteMany = deleteManyDe(enCurso);
        tx.compra_borradores.findFirst = findFirstDe(enCurso);
        const r = await cb(tx);
        filas.splice(0, filas.length, ...enCurso);
        return r;
      }),
    };
    const service = new ComprasService(prisma, {} as any, {} as any, {} as any, {} as any, new CompraBorradoresService(prisma), { logEnTransaccion: jest.fn() } as any) as any;
    service.validateCreateOrUpdatePayload = jest.fn().mockResolvedValue(undefined);
    service.assertComprobanteNoDuplicado = jest.fn().mockResolvedValue(undefined);
    // Primer paso de la compra después de consumir el borrador; acá se corta el flujo a propósito.
    service.validateCabeceraRefs = jest.fn().mockRejectedValue(new Error('falla posterior de la compra'));
    return { service, prisma, tx };
  };

  const V1 = new Date('2026-10-21T10:05:00.123Z');
  const V2 = new Date('2026-10-21T10:09:00.456Z');
  const dto = (borrador_id?: string, borrador_version: string | undefined = V1.toISOString()) => ({
    cabecera: { proveedor_id: 'prov-1', deposito_id: 'dep-1' },
    items: [{ descripcion: 'x', cantidad: 1, precio_unitario: 1 }],
    ...(borrador_id ? { borrador_id, ...(borrador_version ? { borrador_version } : {}) } : {}),
  });

  it('create con borrador_id lo borra en la misma transacción, antes de cualquier paso de la compra', async () => {
    const filas = [{ id: 'b-1', empresa_id: EMP, usuario_id: USR, updated_at: V1 }];
    const { service, prisma, tx } = montar(filas);
    await service.create(dto('b-1'), EMP, USR).catch(() => undefined);

    expect(tx.compra_borradores.deleteMany).toHaveBeenCalledWith({
      where: { id: 'b-1', empresa_id: EMP, usuario_id: USR, updated_at: V1 },
    });
    expect(prisma.compra_borradores.deleteMany).not.toHaveBeenCalled();
    expect(tx.compra_borradores.deleteMany.mock.invocationCallOrder[0]).toBeLessThan(
      service.validateCabeceraRefs.mock.invocationCallOrder[0],
    );
  });

  it('si create falla después, el borrador sigue', async () => {
    const filas = [{ id: 'b-1', empresa_id: EMP, usuario_id: USR, updated_at: V1 }];
    const { service } = montar(filas);

    await expect(service.create(dto('b-1'), EMP, USR)).rejects.toThrow('falla posterior de la compra');
    expect(filas).toEqual([{ id: 'b-1', empresa_id: EMP, usuario_id: USR, updated_at: V1 }]);
  });

  it.each([
    ['de otro usuario', [{ id: 'b-1', empresa_id: EMP, usuario_id: 'usr-2', updated_at: V1 }]],
    ['de otra empresa', [{ id: 'b-1', empresa_id: 'emp-2', usuario_id: USR, updated_at: V1 }]],
    ['inexistente', []],
  ])('borrador_id %s → 404 BORRADOR_NO_ENCONTRADO y no se crea la compra', async (_caso, filas) => {
    const copia = filas.map((f) => ({ ...f }));
    const { service, tx, prisma } = montar(copia);
    const { status, cuerpo } = await errorDe(service.create(dto('b-1'), EMP, USR));

    expect(status).toBe(404);
    expect(cuerpo.codigo).toBe('BORRADOR_NO_ENCONTRADO');
    expect(service.validateCabeceraRefs).not.toHaveBeenCalled();
    expect(tx.compra_cab.create).not.toHaveBeenCalled();
    expect(prisma.compra_cab.create).not.toHaveBeenCalled();
    expect(copia).toEqual(filas);
  });

  it('create sin usuario con borrador_id → 404 sin borrar nada', async () => {
    const filas = [{ id: 'b-1', empresa_id: EMP, usuario_id: USR, updated_at: V1 }];
    const { service, tx } = montar(filas);
    const { status } = await errorDe(service.create(dto('b-1'), EMP, undefined));

    expect(status).toBe(404);
    expect(tx.compra_borradores.deleteMany).not.toHaveBeenCalled();
    expect(filas).toHaveLength(1);
  });

  it('borrador guardado después en otra pestaña (versión vieja) → 409 DATOS_CAMBIADOS, no se crea la compra y el borrador sigue', async () => {
    const filas = [{ id: 'b-1', empresa_id: EMP, usuario_id: USR, updated_at: V2 }];
    const { service, tx, prisma } = montar(filas);
    const { status, cuerpo } = await errorDe(service.create(dto('b-1', V1.toISOString()), EMP, USR));

    expect(status).toBe(409);
    expect(cuerpo.codigo).toBe('DATOS_CAMBIADOS');
    expect(service.validateCabeceraRefs).not.toHaveBeenCalled();
    expect(tx.compra_cab.create).not.toHaveBeenCalled();
    expect(prisma.compra_cab.create).not.toHaveBeenCalled();
    expect(filas).toEqual([{ id: 'b-1', empresa_id: EMP, usuario_id: USR, updated_at: V2 }]);
  });

  it('borrador_id sin borrador_version → 400 CAMPO_REQUERIDO sin borrar nada', async () => {
    const filas = [{ id: 'b-1', empresa_id: EMP, usuario_id: USR, updated_at: V1 }];
    const { service, tx } = montar(filas);
    const { status, cuerpo } = await errorDe(service.create(dto('b-1', ''), EMP, USR));

    expect(status).toBe(400);
    expect(cuerpo).toMatchObject({ codigo: 'CAMPO_REQUERIDO', campo: 'borrador_version' });
    expect(tx.compra_borradores.deleteMany).not.toHaveBeenCalled();
    expect(filas).toHaveLength(1);
  });

  it('create sin borrador_id no toca borradores', async () => {
    const { service, tx } = montar([]);
    await service.create(dto(), EMP, USR).catch(() => undefined);

    expect(tx.compra_borradores.deleteMany).not.toHaveBeenCalled();
    expect(service.validateCabeceraRefs).toHaveBeenCalled();
  });
});
