import { HttpException } from '@nestjs/common';
import { ProductosService } from './productos.service';
import { resolverPermisos } from './permisos-columnas';

jest.mock('./permisos-columnas', () => ({ resolverPermisos: jest.fn() }));

/** Producto guardado: Gravado 10/10 (lo que tienen 4.690 de Kety), precio 10.000, costo 7.000. */
const BASE = () => ({
  id: 'p-1',
  empresa_id: 'emp',
  descripcion: 'P',
  descripcion_larga: 'Larga',
  precio: 10000,
  precio_costo: 7000 as number | null,
  afectacion_id: 'afe-1',
  unidad_medida_id: 'um',
  porcentaje_iva: 10,
  proporcion_iva: 10,
  maneja_lote: false,
  maneja_inventario: true,
  deleted: false,
  es_padre: false,
  cod_producto: 'C1',
});

const permisos = (...codigos: string[]) => (resolverPermisos as jest.Mock).mockResolvedValue(new Set(codigos));
const CODIGOS_AFECTACION: Record<string, string> = { 'afe-1': '1', 'afe-3': '3' };

const crear = (o: { producto?: Record<string, unknown>; moduloLotes?: boolean; lotesVivos?: boolean; marca?: unknown; duplicado?: unknown } = {}) => {
  const guardado = { ...BASE(), ...(o.producto ?? {}) };
  const prisma: any = {
    productos: {
      findUnique: jest.fn().mockImplementation(async (args: any) => (args.select ? { ...guardado, producto_imagenes: [], producto_variante_valores: [], hijos_variantes: [] } : guardado)),
      findFirst: jest.fn().mockResolvedValue(o.duplicado ?? null),
      update: jest.fn().mockImplementation(async ({ data }: any) => ({ ...guardado, ...data })),
      create: jest.fn().mockImplementation(async ({ data }: any) => ({ ...data })),
      updateMany: jest.fn(),
    },
    afectacion_iva: { findUnique: jest.fn().mockImplementation(async ({ where }: any) => ({ id: where.id, codigo: CODIGOS_AFECTACION[where.id] ?? '1' })) },
    unidades_de_medida: { findUnique: jest.fn().mockResolvedValue({ id: 'um' }) },
    empresas: { findUnique: jest.fn().mockResolvedValue({ id: 'emp' }) },
    marcas: { findFirst: jest.fn().mockResolvedValue(o.marca === undefined ? { id: 'm-1' } : o.marca) },
    categorias: { findFirst: jest.fn().mockResolvedValue({ id: 'c-1', activo: true }) },
    lotes_producto: { findMany: jest.fn().mockResolvedValue(o.lotesVivos ? [{ producto_id: 'p-1' }] : []) },
    producto_variante_valores: { deleteMany: jest.fn(), createMany: jest.fn() },
    $transaction: jest.fn(async (fn: any) => fn({})),
  };
  const lotesService: any = {
    crearLoteInicial: jest.fn().mockResolvedValue({ lote_id: 'l', cantidad: 3 }),
    empresaConModuloLotes: jest.fn().mockResolvedValue(o.moduloLotes ?? true),
  };
  const service = new ProductosService(
    prisma,
    { get: () => undefined } as any,
    { log: jest.fn().mockResolvedValue(undefined) } as any,
    { checkLimit: jest.fn().mockResolvedValue(undefined) } as any,
    {} as any,
    lotesService,
  );
  jest.spyOn(service as any, 'getPublicBaseUrl').mockReturnValue('https://cdn');
  return { service, prisma, lotesService };
};

/** El error HTTP que tira la promesa: status y cuerpo. */
async function rechazo(p: Promise<unknown>): Promise<{ status: number; cuerpo: any }> {
  try {
    await p;
  } catch (e) {
    if (e instanceof HttpException) return { status: e.getStatus(), cuerpo: e.getResponse() };
    throw e;
  }
  throw new Error('no rechazó');
}

const datosUpdate = (prisma: any) => prisma.productos.update.mock.calls[0][0].data;

beforeEach(() => {
  jest.clearAllMocks();
  permisos();
});

describe('fichaCatalogo', () => {
  it('con INV_STK_COSTO_VER trae precio_costo 7000 y descripcion_larga', async () => {
    permisos('INV_STK_COSTO_VER');
    const r = await crear().service.fichaCatalogo('p-1', 'emp', 'u-1');
    expect(r.data).toMatchObject({ precio_costo: 7000, descripcion_larga: 'Larga' });
  });

  it('sin el permiso no trae la clave precio_costo', async () => {
    const r = await crear().service.fichaCatalogo('p-1', 'emp', 'u-1');
    expect(r.data).not.toHaveProperty('precio_costo');
    expect(JSON.stringify(r)).not.toContain('7000');
  });

  it('borrado da 404 con codigo PRODUCTO_NO_ENCONTRADO', async () => {
    const r = await rechazo(crear({ producto: { deleted: true } }).service.fichaCatalogo('p-1', 'emp', 'u-1'));
    expect(r).toMatchObject({ status: 404, cuerpo: { codigo: 'PRODUCTO_NO_ENCONTRADO' } });
  });

  it('findOne suma descripcion_larga al select y conserva precio_costo', async () => {
    const { service, prisma } = crear();
    const r = await service.findOne('p-1', 'emp');
    const select = prisma.productos.findUnique.mock.calls[0][0].select;
    expect(select.descripcion_larga).toBe(true);
    expect(select.precio_costo).toBe(true);
    expect(r.data).toHaveProperty('precio_costo', 7000);
  });
});

describe('update: permisos de montos (A4)', () => {
  it.each([
    [{ precio: 1 }, 'PRODUCTO_PRECIO_SIN_PERMISO', 'precio'],
    [{ precio_costo: 1 }, 'PRODUCTO_COSTO_SIN_PERMISO', 'precio_costo'],
    [{ precio_costo: null }, 'PRODUCTO_COSTO_SIN_PERMISO', 'precio_costo'],
  ])('%j sin permiso: 403 %s y no escribe', async (dto, codigo, campo) => {
    const { service, prisma } = crear();
    const r = await rechazo(service.update('p-1', dto as any, 'emp', 'u-1'));
    expect(r).toMatchObject({ status: 403, cuerpo: { codigo, campo } });
    expect(prisma.productos.update).not.toHaveBeenCalled();
  });

  it.each([[{ precio: 10000 }], [{ precio_costo: 7000 }]])('%j sin permiso pasa (repite lo guardado, D5)', async (dto) => {
    const { service, prisma } = crear();
    await service.update('p-1', dto as any, 'emp', 'u-1');
    expect(prisma.productos.update).toHaveBeenCalledTimes(1);
  });

  it('{ precio: 1 } con permiso pasa con precio 1', async () => {
    permisos('INV_PRD_PRECIO_BASE_EDITAR');
    const { service, prisma } = crear();
    await service.update('p-1', { precio: 1 } as any, 'emp', 'u-1');
    expect(datosUpdate(prisma).precio).toBe(1);
  });

  it('{ descripcion } sin permisos pasa y no pregunta permisos', async () => {
    const { service } = crear();
    await service.update('p-1', { descripcion: 'X' } as any, 'emp', 'u-1');
    expect(resolverPermisos).not.toHaveBeenCalled();
  });

  it('costo null guardado y { precio_costo: 0 } pasa', async () => {
    const { service, prisma } = crear({ producto: { precio_costo: null } });
    await service.update('p-1', { precio_costo: 0 } as any, 'emp', 'u-1');
    expect(prisma.productos.update).toHaveBeenCalledTimes(1);
  });

  it('la fila entera del front viejo (precio igual, costo 0 sobre null, IVA coherente igual) sin permisos de montos: pasa (D5, F5)', async () => {
    const { service, prisma } = crear({ producto: { precio_costo: null, proporcion_iva: 100 } });
    await service.update(
      'p-1',
      { descripcion: 'P', precio: 10000, precio_costo: 0, afectacion_id: 'afe-1', porcentaje_iva: 10, proporcion_iva: 100, unidad_medida_id: 'um', maneja_inventario: true, maneja_lote: false } as any,
      'emp',
      'u-1',
    );
    expect(prisma.productos.update).toHaveBeenCalledTimes(1);
  });
});

describe('update: IVA solo si el pedido lo cambia (A4)', () => {
  it('{ descripcion } sobre 10/10 pasa sin mirar la afectación ni tocar el IVA', async () => {
    const { service, prisma } = crear();
    await service.update('p-1', { descripcion: 'X' } as any, 'emp', 'u-1');
    expect(prisma.afectacion_iva.findUnique).not.toHaveBeenCalled();
    expect(datosUpdate(prisma).proporcion_iva).toBeUndefined();
    expect(datosUpdate(prisma).porcentaje_iva).toBeUndefined();
  });

  it('los tres iguales a lo guardado pasan', async () => {
    const { service, prisma } = crear();
    await service.update('p-1', { afectacion_id: 'afe-1', porcentaje_iva: 10, proporcion_iva: 10 } as any, 'emp', 'u-1');
    expect(prisma.productos.update).toHaveBeenCalledTimes(1);
  });

  it('{ proporcion_iva: 100 } pasa', async () => {
    const { service, prisma } = crear();
    await service.update('p-1', { proporcion_iva: 100 } as any, 'emp', 'u-1');
    expect(datosUpdate(prisma).proporcion_iva).toBe(100);
  });

  it.each([[{ porcentaje_iva: 5 }], [{ afectacion_id: 'afe-3' }]])('%j: 409 IVA_INCOHERENTE', async (dto) => {
    const { service, prisma } = crear();
    const r = await rechazo(service.update('p-1', dto as any, 'emp', 'u-1'));
    expect(r).toMatchObject({ status: 409, cuerpo: { codigo: 'IVA_INCOHERENTE' } });
    expect(prisma.productos.update).not.toHaveBeenCalled();
  });

  it('Exento con 0/0 pasa', async () => {
    const { service, prisma } = crear();
    await service.update('p-1', { afectacion_id: 'afe-3', porcentaje_iva: 0, proporcion_iva: 0 } as any, 'emp', 'u-1');
    expect(prisma.productos.update).toHaveBeenCalledTimes(1);
  });
});

describe('update: orden (un rechazo no crea lote inicial)', () => {
  it.each([
    ['sin permiso de precio', { maneja_lote: true, precio: 1 }, 403],
    ['IVA incoherente', { maneja_lote: true, porcentaje_iva: 5 }, 409],
  ])('%s: %j da %s y no llama crearLoteInicial', async (_t, dto, status) => {
    const { service, lotesService } = crear();
    const r = await rechazo(service.update('p-1', dto as any, 'emp', 'u-1'));
    expect(r.status).toBe(status);
    expect(lotesService.crearLoteInicial).not.toHaveBeenCalled();
  });

  it('activar lotes sin módulo: 409 LOTES_SIN_MODULO sin lote inicial', async () => {
    const { service, lotesService } = crear({ moduloLotes: false });
    const r = await rechazo(service.update('p-1', { maneja_lote: true } as any, 'emp', 'u-1'));
    expect(r).toMatchObject({ status: 409, cuerpo: { codigo: 'LOTES_SIN_MODULO' } });
    expect(lotesService.crearLoteInicial).not.toHaveBeenCalled();
  });

  it('activar lotes con módulo crea el lote inicial una vez', async () => {
    const { service, lotesService } = crear();
    await service.update('p-1', { maneja_lote: true } as any, 'emp', 'u-1');
    expect(lotesService.crearLoteInicial).toHaveBeenCalledTimes(1);
  });

  it('desactivar con lotes vivos: 409 LOTE_CON_STOCK', async () => {
    const { service } = crear({ producto: { maneja_lote: true }, lotesVivos: true });
    const r = await rechazo(service.update('p-1', { maneja_lote: false } as any, 'emp', 'u-1'));
    expect(r).toMatchObject({ status: 409, cuerpo: { codigo: 'LOTE_CON_STOCK' } });
  });

  it('marca de otra empresa: 400 MARCA_INVALIDA en marca_id', async () => {
    const { service } = crear({ marca: null });
    const r = await rechazo(service.update('p-1', { marca_id: 'm-otra' } as any, 'emp', 'u-1'));
    expect(r).toMatchObject({ status: 400, cuerpo: { codigo: 'MARCA_INVALIDA', campo: 'marca_id' } });
  });

  it('vaciar código, código de barras, categoría y marca escribe null', async () => {
    const { service, prisma } = crear();
    await service.update('p-1', { cod_producto: null, codigo_barra: null, categoria_id: null, marca_id: null } as any, 'emp', 'u-1');
    expect(datosUpdate(prisma)).toMatchObject({ cod_producto: null, codigo_barra: null, categoria_id: null, marca_id: null });
  });
});

describe('create (A5)', () => {
  const DTO = { descripcion: 'Nuevo', afectacion_id: 'afe-1', unidad_medida_id: 'um', porcentaje_iva: 10, proporcion_iva: 100 };
  const datosCreate = (prisma: any) => prisma.productos.create.mock.calls[0][0].data;

  it('precio 10000 sin permiso: 403', async () => {
    const r = await rechazo(crear().service.create({ ...DTO, precio: 10000 } as any, 'emp', 'u-1'));
    expect(r).toMatchObject({ status: 403, cuerpo: { codigo: 'PRODUCTO_PRECIO_SIN_PERMISO' } });
  });

  it('precio 0 sin permiso pasa', async () => {
    const { service, prisma } = crear();
    await service.create({ ...DTO, precio: 0 } as any, 'emp', 'u-1');
    expect(prisma.productos.create).toHaveBeenCalledTimes(1);
  });

  it('sin precio ni costo y sin permisos (la alta rápida) pasa: precio 0, costo null', async () => {
    const { service, prisma } = crear();
    await service.create(DTO as any, 'emp', 'u-1');
    expect(datosCreate(prisma)).toMatchObject({ precio: 0, precio_costo: null });
    expect(resolverPermisos).not.toHaveBeenCalled();
  });

  it('precio_costo 7000 con INV_PRD_COSTO_EDITAR lo escribe', async () => {
    permisos('INV_PRD_COSTO_EDITAR');
    const { service, prisma } = crear();
    await service.create({ ...DTO, precio_costo: 7000 } as any, 'emp', 'u-1');
    expect(datosCreate(prisma).precio_costo).toBe(7000);
  });

  it('escribe descripcion_larga', async () => {
    const { service, prisma } = crear();
    await service.create({ ...DTO, descripcion_larga: 'Larga' } as any, 'emp', 'u-1');
    expect(datosCreate(prisma).descripcion_larga).toBe('Larga');
  });

  it('maneja_lote sin el módulo: 409 LOTES_SIN_MODULO', async () => {
    const r = await rechazo(crear({ moduloLotes: false }).service.create({ ...DTO, maneja_lote: true } as any, 'emp', 'u-1'));
    expect(r).toMatchObject({ status: 409, cuerpo: { codigo: 'LOTES_SIN_MODULO' } });
  });

  it('duplicado vivo: 409 PRODUCTO_DUPLICADO en descripcion, buscando solo vivos', async () => {
    const { service, prisma } = crear({ duplicado: { id: 'p-9', deleted: false } });
    const r = await rechazo(service.create(DTO as any, 'emp', 'u-1'));
    expect(r).toMatchObject({ status: 409, cuerpo: { codigo: 'PRODUCTO_DUPLICADO', campo: 'descripcion' } });
    expect(prisma.productos.findFirst.mock.calls[0][0].where.deleted).toBe(false);
  });

  it('marca ajena: 400 con codigo, no 500', async () => {
    const r = await rechazo(crear({ marca: null }).service.create({ ...DTO, marca_id: 'm-otra' } as any, 'emp', 'u-1'));
    expect(r).toMatchObject({ status: 400, cuerpo: { codigo: 'MARCA_INVALIDA' } });
  });

  it('IVA incoherente: 409 IVA_INCOHERENTE', async () => {
    const r = await rechazo(crear().service.create({ ...DTO, proporcion_iva: 10 } as any, 'emp', 'u-1'));
    expect(r).toMatchObject({ status: 409, cuerpo: { codigo: 'IVA_INCOHERENTE' } });
  });
});

describe('addImagen', () => {
  it('con 5 imágenes: 409 IMAGENES_LIMITE', async () => {
    const { service, prisma } = crear();
    prisma.producto_imagenes = { count: jest.fn().mockResolvedValue(5) };
    const r = await rechazo(service.addImagen('p-1', { buffer: Buffer.from('x') } as any, {} as any, 'emp', 'u-1'));
    expect(r).toMatchObject({ status: 409, cuerpo: { codigo: 'IMAGENES_LIMITE' } });
  });
});
