import { whereProductoPorRubro } from 'src/common/utils/rubros.util';
import { rubrosFiltroUsuario } from 'src/utils/alcance-rubro';
import { BusquedaService } from './busqueda.service';

jest.mock('src/utils/alcance-rubro', () => ({ rubrosFiltroUsuario: jest.fn() }));
const rubros = rubrosFiltroUsuario as jest.Mock;
beforeEach(() => rubros.mockReset().mockResolvedValue(null));

/**
 * `GET /busqueda`: cada grupo sale solo si el usuario tiene módulo + submódulo + permiso VER (los mismos que la pantalla
 * de ese dato), siempre de la empresa del token. Comprobantes con el mismo alcance que el listado (sucursal, sin alcance
 * propio): lo resuelve `FacturasService.buscarPorNumero`, acá se prueba que se le pasa usuario y empresa.
 */

type Plan = { modulos: string[]; submodulos: Array<{ codigo: string; modulo: string; es_addon?: boolean; fin_prueba?: Date | null }>; excluidos?: string[] };

const SUBS = [
  { codigo: 'VENTAS_CLIENTES', modulo: 'VENTAS' },
  { codigo: 'VENTAS_FACTURACION', modulo: 'VENTAS' },
  { codigo: 'INV_PRODUCTOS', modulo: 'INVENTARIO' },
];
const PLAN_COMPLETO: Plan = { modulos: ['VENTAS', 'INVENTARIO'], submodulos: SUBS };
const TODOS = [
  { modulo: 'VENTAS', privilegio: 'VEN_CLI_CLIENTE_VER' },
  { modulo: 'INVENTARIO', privilegio: 'INV_PRD_PRODUCTO_VER' },
  { modulo: 'VENTAS', privilegio: 'VEN_FAC_FACTURA_VER' },
];

function armar({ plan = PLAN_COMPLETO, privilegios = TODOS, superadmin = false, tipoEmpresa = 'empresa' } = {}) {
  const prisma: any = {
    usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: superadmin }) },
    empresas: { findUnique: jest.fn().mockResolvedValue({ type: tipoEmpresa }) },
    suscripciones: { findFirst: jest.fn().mockResolvedValue({ id: 'sus-1' }) },
    suscripcion_modulos: { findMany: jest.fn().mockResolvedValue(plan.modulos.map((m) => ({ modulo_id: `mod-${m}` }))) },
    suscripcion_submodulos: {
      findMany: jest.fn().mockResolvedValue([
        ...plan.submodulos.filter((s) => s.es_addon || s.fin_prueba).map((s) => ({ submodulo_id: `sub-${s.codigo}`, active: true, fecha_fin_prueba: s.fin_prueba ?? null })),
        ...(plan.excluidos ?? []).map((c) => ({ submodulo_id: `sub-${c}`, active: false, fecha_fin_prueba: null })),
      ]),
    },
    submodulos: {
      findFirst: jest.fn(({ where }: any) => {
        const s = SUBS.find((x) => x.codigo === where.codigo);
        const delPlan = plan.submodulos.find((x) => x.codigo === where.codigo);
        return Promise.resolve(s ? { id: `sub-${s.codigo}`, modulo_id: `mod-${s.modulo}`, es_addon: !!delPlan?.es_addon } : null);
      }),
    },
    perfiles_privilegios: {
      findMany: jest.fn(({ where }: any) =>
        Promise.resolve(
          privilegios
            .filter((p) => where.privilegios.codigo.in.includes(p.privilegio))
            .map((p) => ({ privilegios: { codigo: p.privilegio }, modulos: { codigo: p.modulo } })),
        ),
      ),
    },
    clientes: {
      findMany: jest.fn().mockResolvedValue([{ id: 'c1', personas: { razon_social: 'JUAN PEREZ', ruc: '1234567', dv: '8' } }]),
    },
    productos: { findMany: jest.fn().mockResolvedValue([{ id: 'p1', cod_producto: 'A-1', descripcion: 'ARROZ 1KG' }]) },
  };
  const facturas: any = {
    buscarPorNumero: jest.fn().mockResolvedValue([
      {
        id: 'f1',
        dest: '001',
        dpunexp: '002',
        dnumdoc: '0000123',
        dfeemide: new Date('2026-11-01T10:00:00.000Z'),
        clientes: { personas: { razon_social: 'JUAN PEREZ' } },
        factura_subtotales: [{ dtotgralope: '150000.00000000' }],
        moneda: { codigo: 'PYG' },
      },
    ]),
  };
  return { svc: new BusquedaService(prisma, facturas), prisma, facturas };
}

describe('BusquedaService.buscar', () => {
  it('con los tres permisos devuelve los tres grupos con la forma pedida', async () => {
    const { svc } = armar();
    await expect(svc.buscar('123', 'emp-1', 'usr-1')).resolves.toEqual({
      clientes: [{ id: 'c1', nombre: 'JUAN PEREZ', ruc: '1234567-8' }],
      productos: [{ id: 'p1', codigo: 'A-1', nombre: 'ARROZ 1KG' }],
      comprobantes: [
        { id: 'f1', numero: '001-002-0000123', fecha: '2026-11-01T10:00:00.000Z', cliente: 'JUAN PEREZ', total: 150000, moneda: { codigo: 'PYG' } },
      ],
    });
  });

  it('el grupo sin permiso VER no aparece y no se consulta', async () => {
    const { svc, prisma, facturas } = armar({ privilegios: [{ modulo: 'VENTAS', privilegio: 'VEN_CLI_CLIENTE_VER' }] });
    const r = await svc.buscar('123', 'emp-1', 'usr-1');
    expect(Object.keys(r)).toEqual(['clientes']);
    expect(prisma.productos.findMany).not.toHaveBeenCalled();
    expect(facturas.buscarPorNumero).not.toHaveBeenCalled();
  });

  it('el permiso grabado con otro módulo no cuenta (mismo criterio que PermissionGuard)', async () => {
    const { svc } = armar({ privilegios: [{ modulo: 'COBRANZAS', privilegio: 'VEN_CLI_CLIENTE_VER' }] });
    await expect(svc.buscar('123', 'emp-1', 'usr-1')).resolves.toEqual({});
  });

  it('sin el módulo en el plan el grupo no aparece aunque tenga el permiso', async () => {
    const { svc } = armar({ plan: { modulos: ['VENTAS'], submodulos: SUBS } });
    const r = await svc.buscar('123', 'emp-1', 'usr-1');
    expect(Object.keys(r).sort()).toEqual(['clientes', 'comprobantes']);
  });

  it('con el submódulo excluido para la empresa el grupo no aparece', async () => {
    const { svc } = armar({ plan: { ...PLAN_COMPLETO, excluidos: ['VENTAS_FACTURACION'] } });
    const r = await svc.buscar('123', 'emp-1', 'usr-1');
    expect(Object.keys(r).sort()).toEqual(['clientes', 'productos']);
  });

  it('con la prueba del submódulo vencida hace más de 30 días el grupo no aparece', async () => {
    const vencida = new Date(Date.now() - 60 * 86400000);
    const { svc } = armar({ plan: { ...PLAN_COMPLETO, submodulos: SUBS.map((s) => (s.codigo === 'INV_PRODUCTOS' ? { ...s, fin_prueba: vencida } : s)) } });
    const r = await svc.buscar('123', 'emp-1', 'usr-1');
    expect(Object.keys(r).sort()).toEqual(['clientes', 'comprobantes']);
  });

  it('el superadmin pasa el permiso pero no el plan', async () => {
    const { svc } = armar({ superadmin: true, privilegios: [], plan: { modulos: ['VENTAS'], submodulos: SUBS } });
    const r = await svc.buscar('123', 'emp-1', 'usr-1');
    expect(Object.keys(r).sort()).toEqual(['clientes', 'comprobantes']);
  });

  it('clientes y productos se filtran por la empresa del token y piden 5', async () => {
    const { svc, prisma } = armar();
    await svc.buscar('juan', 'emp-1', 'usr-1');
    const wc = prisma.clientes.findMany.mock.calls[0][0];
    expect(wc.where.personas.empresa_id).toBe('emp-1');
    expect(wc.where.deleted).toBe(false);
    expect(wc.take).toBe(5);
    const wp = prisma.productos.findMany.mock.calls[0][0];
    expect(wp.where.empresa_id).toBe('emp-1');
    expect(wp.where.deleted).toBe(false);
    expect(wp.take).toBe(5);
  });

  it('comprobantes: delega en buscarPorNumero con empresa y usuario (alcance de sucursal del listado), máximo 5', async () => {
    const { svc, facturas } = armar();
    await svc.buscar(' 001-002-123 ', 'emp-1', 'usr-1');
    expect(facturas.buscarPorNumero).toHaveBeenCalledWith('001-002-123', 'emp-1', 'usr-1', 5);
  });

  it('productos: con el usuario limitado a un rubro, el filtro de rubro va bajo AND (como /productos/search)', async () => {
    rubros.mockResolvedValue(['rub-1']);
    const { svc, prisma } = armar();
    await svc.buscar('arroz', 'emp-1', 'usr-1');
    expect(rubros).toHaveBeenCalledWith(prisma, 'usr-1', 'emp-1');
    const wp = prisma.productos.findMany.mock.calls[0][0];
    expect(wp.where.AND).toEqual(whereProductoPorRubro(['rub-1']).AND);
    expect(wp.where.AND.length).toBeGreaterThan(0);
    expect(wp.where.OR).toBeDefined();
  });

  it('el texto va escapado a LIKE en clientes y productos (% y _ no son comodines)', async () => {
    const { svc, prisma, facturas } = armar();
    await svc.buscar('%_', 'emp-1', 'usr-1');
    const oc = prisma.clientes.findMany.mock.calls[0][0].where.personas.OR;
    expect(oc.map((c: any) => Object.values(c)[0].contains)).toEqual(['\\%\\_', '\\%\\_', '\\%\\_']);
    const op = prisma.productos.findMany.mock.calls[0][0].where.OR;
    expect(op[0].descripcion.contains).toBe('\\%\\_');
    expect(op[3].producto_presentaciones.some.codigo_barra.equals).toBe('%_');
    // Comprobantes: '%_' no es un número, buscarPorNumero devuelve [] sin consultar (recibe el texto original).
    expect(facturas.buscarPorNumero).toHaveBeenCalledWith('%_', 'emp-1', 'usr-1', 5);
  });
});

