import { LotesService } from './lotes.service';
import { alcanceSucursalUsuario } from 'src/utils/alcance-sucursal';
import { resolverPermisos } from 'src/productos/permisos-columnas';

jest.mock('src/utils/alcance-sucursal', () => ({ ...jest.requireActual('src/utils/alcance-sucursal'), alcanceSucursalUsuario: jest.fn().mockResolvedValue(null), filtroSucursalDeposito: jest.fn() }));
jest.mock('src/productos/permisos-columnas', () => ({ resolverPermisos: jest.fn() }));

const ITEM = { id: 'sl', lotes_producto: { id: 'l', numero_lote: 'A', costo_unitario: 1120, productos: { id: 'p' } } };

function crear(monedaPrincipal: string | null = null) {
  const prisma: any = {
    empresas_sucursales: {
      findFirst: jest.fn().mockResolvedValue({ id: 's1' }),
      findMany: jest.fn().mockResolvedValue([{ id: 's1', descripcion: 'Matriz' }]),
    },
    depositos: { findMany: jest.fn().mockResolvedValue([{ id: 'd1', descripcion: 'Uno', sucursal_id: 's1' }]), findFirst: jest.fn() },
    stock_lote: {
      findMany: jest.fn().mockResolvedValue([ITEM]),
      count: jest.fn().mockResolvedValue(1),
      aggregate: jest.fn().mockResolvedValue({ _sum: { cantidad_disponible: 3 } }),
    },
    // La base: la principal de la empresa; sin principal, PYG del catálogo (monedaBaseId).
    empresa_monedas: { findFirst: jest.fn().mockResolvedValue(monedaPrincipal ? { moneda_id: 'm-principal' } : null) },
    moneda: {
      findFirst: jest.fn().mockResolvedValue({ id: 'm-pyg' }),
      findUnique: jest.fn(({ where }: any) => Promise.resolve({ id: where.id, codigo: where.id === 'm-pyg' ? 'PYG' : monedaPrincipal })),
    },
    lotes_producto: { findFirst: jest.fn(), update: jest.fn().mockResolvedValue({ numero_lote: 'N' }) },
    $transaction: jest.fn(async (ops: any[]) => Promise.all(ops)),
  };
  const audit: any = { log: jest.fn() };
  const service = new LotesService(prisma, audit);
  // La pantalla ya resolvió que Lotes está habilitado: acá no se prueba esa parte.
  jest.spyOn(service as any, 'ensureEnabledForEmpresa').mockResolvedValue(undefined);
  return { service, prisma };
}

describe('LotesService.list: costo por permiso y moneda', () => {
  it('sin INV_STK_COSTO_VER: costo null y los filtros de costo no llegan al where', async () => {
    (resolverPermisos as jest.Mock).mockResolvedValue(new Set());
    const { service, prisma } = crear();
    const r: any = await service.list('emp', { sucursal_id: 's1', costo_desde: '1' }, 'usr');
    expect(r.items[0].lotes_producto.costo_unitario).toBeNull();
    expect(JSON.stringify(prisma.stock_lote.findMany.mock.calls[0][0].where)).not.toContain('costo_unitario');
  });

  it('con el permiso: el valor y el filtro', async () => {
    (resolverPermisos as jest.Mock).mockResolvedValue(new Set(['INV_STK_COSTO_VER']));
    const { service, prisma } = crear();
    const r: any = await service.list('emp', { sucursal_id: 's1', costo_desde: '1' }, 'usr');
    expect(r.items[0].lotes_producto.costo_unitario).toBe(1120);
    expect(JSON.stringify(prisma.stock_lote.findMany.mock.calls[0][0].where)).toContain('costo_unitario');
  });

  it('moneda: PYG por defecto y la principal de la empresa si la hay', async () => {
    (resolverPermisos as jest.Mock).mockResolvedValue(new Set());
    expect(((await crear().service.list('emp', { sucursal_id: 's1' }, 'usr')) as any).moneda).toBe('PYG');
    expect(((await crear('USD').service.list('emp', { sucursal_id: 's1' }, 'usr')) as any).moneda).toBe('USD');
  });
});

describe('LotesService.findByProducto: costo por permiso', () => {
  const crearConLotes = () => {
    const c = crear();
    jest.spyOn(c.service as any, 'resolveSucursalOperativa').mockResolvedValue('s1');
    c.prisma.productos = { findFirst: jest.fn().mockResolvedValue({ id: 'p' }) };
    c.prisma.stock_lote.findMany.mockResolvedValue([ITEM]);
    return c;
  };

  it('sin INV_STK_COSTO_VER el costo de cada lote no sale', async () => {
    (resolverPermisos as jest.Mock).mockResolvedValue(new Set());
    const { service } = crearConLotes();
    const r: any = await service.findByProducto('emp', 'p', 'usr');
    expect(r.items[0].lotes_producto.costo_unitario).toBeNull();
    expect(JSON.stringify(r)).not.toContain('1120');
    expect(r.items[0].lotes_producto.numero_lote).toBe('A');
  });

  it('con el permiso, el valor', async () => {
    (resolverPermisos as jest.Mock).mockResolvedValue(new Set(['INV_STK_COSTO_VER']));
    const { service } = crearConLotes();
    const r: any = await service.findByProducto('emp', 'p', 'usr');
    expect(r.items[0].lotes_producto.costo_unitario).toBe(1120);
  });
});

describe('LotesService.opciones', () => {
  it('con alcance, solo las sucursales y depósitos asignados', async () => {
    (alcanceSucursalUsuario as jest.Mock).mockResolvedValueOnce({ sucursalIds: ['s1'], puntosEstablecimiento: [], depositoIds: ['d1'] });
    const { service, prisma } = crear();
    const r = await service.opciones('emp', 'usr');
    expect(prisma.empresas_sucursales.findMany.mock.calls[0][0].where.id).toEqual({ in: ['s1'] });
    expect(prisma.depositos.findMany.mock.calls[0][0].where.sucursal.id).toEqual({ in: ['s1'] });
    expect(r.sucursales).toEqual([{ id: 's1', descripcion: 'Matriz' }]);
    expect(r.depositos).toHaveLength(1);
  });
});

describe('LotesService.editar: códigos de error', () => {
  const lote = { id: 'l', producto_id: 'p', numero_lote: 'A', fecha_fabricacion: new Date('2026-01-10'), fecha_vencimiento: null };

  it('otra empresa: LOTE_NO_ENCONTRADO', async () => {
    const { service, prisma } = crear();
    prisma.lotes_producto.findFirst.mockResolvedValue(null);
    await expect(service.editar('emp', 'l', { numero_lote: 'N' } as any, 'usr')).rejects.toMatchObject({ status: 404, response: { codigo: 'LOTE_NO_ENCONTRADO' } });
  });
  it('número repetido: LOTE_NUMERO_REPETIDO en numero_lote, con el mensaje de siempre', async () => {
    const { service, prisma } = crear();
    prisma.lotes_producto.findFirst.mockResolvedValueOnce(lote).mockResolvedValueOnce({ id: 'otro' });
    await expect(service.editar('emp', 'l', { numero_lote: 'B' } as any, 'usr')).rejects.toMatchObject({
      response: { codigo: 'LOTE_NUMERO_REPETIDO', campo: 'numero_lote', message: 'Este producto ya tiene otro lote con el número B' },
    });
  });
  it('número en blanco: LOTE_NUMERO_VACIO', async () => {
    const { service, prisma } = crear();
    prisma.lotes_producto.findFirst.mockResolvedValue(lote);
    await expect(service.editar('emp', 'l', { numero_lote: '  ' } as any, 'usr')).rejects.toMatchObject({ response: { codigo: 'LOTE_NUMERO_VACIO' } });
  });
  it('vencimiento anterior a la fabricación: LOTE_VENCIMIENTO_ANTERIOR en fecha_vencimiento', async () => {
    const { service, prisma } = crear();
    prisma.lotes_producto.findFirst.mockResolvedValue(lote);
    await expect(service.editar('emp', 'l', { fecha_vencimiento: '2026-01-01' } as any, 'usr')).rejects.toMatchObject({
      response: { codigo: 'LOTE_VENCIMIENTO_ANTERIOR', campo: 'fecha_vencimiento', message: 'El vencimiento no puede ser anterior a la fabricación' },
    });
  });
});

describe('LotesService.empresaConModuloLotes', () => {
  const crearConEmpresa = (type: string | null, modulo: boolean) => {
    const prisma: any = {
      empresas: { findUnique: jest.fn().mockResolvedValue(type ? { type } : null) },
      suscripcion_modulos: { findFirst: jest.fn().mockResolvedValue(modulo ? { id: 'sm' } : null) },
      empresas_sucursales: { findFirst: jest.fn() },
    };
    return { service: new LotesService(prisma, { log: jest.fn() } as any), prisma };
  };

  it('holding pasa sin mirar la suscripción', async () => {
    const { service, prisma } = crearConEmpresa('holding', false);
    expect(await service.empresaConModuloLotes('emp')).toBe(true);
    expect(prisma.suscripcion_modulos.findFirst).not.toHaveBeenCalled();
  });

  it('con el módulo activo sí, y sin él no', async () => {
    expect(await crearConEmpresa('empresa', true).service.empresaConModuloLotes('emp')).toBe(true);
    expect(await crearConEmpresa('empresa', false).service.empresaConModuloLotes('emp')).toBe(false);
  });

  it('la suscripción en gracia cuenta como activa', async () => {
    const { service, prisma } = crearConEmpresa('empresa', true);
    await service.empresaConModuloLotes('emp');
    expect(prisma.suscripcion_modulos.findFirst.mock.calls[0][0].where.suscripciones.estado).toEqual({ in: ['Activo', 'EnGracia'] });
  });

  it('motivoDeshabilitado sigue dando sin_modulo', async () => {
    const { service } = crearConEmpresa('empresa', false);
    jest.spyOn(service as any, 'getEmpresaConfig').mockResolvedValue({ active: true, maneja_lotes: true });
    expect(await service.motivoDeshabilitado('emp', 's1')).toBe('sin_modulo');
  });
});
