import { tienePermiso } from 'src/auth/guards/tiene-permiso';
import { SucursalesController } from './sucursales.controller';
import { SucursalesService } from './sucursales.service';

/**
 * `GET /sucursales/:id/detalle` (ADM_SUC_SUCURSAL_VER) traía los depósitos a cualquiera que viera la sucursal. Los depósitos son de
 * INVENTARIO: viajan solo si el usuario tiene `INVENTARIO · INV_DEP_DEPOSITO_VER` con el mismo criterio que `ModuleGuard` + `PermissionGuard`
 * (módulo en la suscripción vigente, addon contratado si el privilegio es de uno, privilegio en sus perfiles; superadmin y holding como el guard).
 */
const SUC = { id: 'suc-1', empresa_id: 'emp-1', descripcion: 'Matriz', cajas: [], asignaciones_usuarios: [] };

interface Escenario {
  superadmin?: boolean;
  tipoEmpresa?: string;
  moduloActivo?: boolean;
  addon?: { es_addon: boolean; contratado: boolean };
  privilegio?: boolean;
}

function prismaCon(e: Escenario = {}) {
  const { superadmin = false, tipoEmpresa = 'empresa', moduloActivo = true, addon, privilegio = true } = e;
  return {
    usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: superadmin }) },
    empresas: { findUnique: jest.fn().mockResolvedValue({ type: tipoEmpresa }) },
    suscripcion_modulos: { findFirst: jest.fn().mockResolvedValue(moduloActivo ? { id: 'sm' } : null) },
    privilegios: {
      findMany: jest.fn().mockResolvedValue([{ codigo: 'INV_DEP_DEPOSITO_VER', submodulos: { id: 'sub-dep', codigo: 'INV_DEPOSITOS', es_addon: addon?.es_addon ?? false } }]),
    },
    suscripcion_submodulos: { findMany: jest.fn().mockResolvedValue(addon?.contratado ? [{ submodulo_id: 'sub-dep' }] : []) },
    perfiles_privilegios: { findFirst: jest.fn().mockResolvedValue(privilegio ? { id: 'pp' } : null) },
    empresas_sucursales: {
      findFirst: jest.fn(({ include }) => Promise.resolve({ ...SUC, ...(include?.depositos ? { depositos: [{ id: 'dep-1' }] } : {}) })),
    },
  };
}

const servicio = (prisma: unknown) => new SucursalesService({} as never, prisma as never, {} as never, {} as never);
const usuario = { id: 'u-1', empresa_id: 'emp-1' };

describe('tienePermiso (mismo criterio que ModuleGuard + PermissionGuard)', () => {
  it('con el módulo en la suscripción y el privilegio en sus perfiles → sí', async () => {
    const prisma = prismaCon();
    await expect(tienePermiso(prisma as never, usuario, 'INVENTARIO', 'INV_DEP_DEPOSITO_VER')).resolves.toBe(true);
    expect(prisma.suscripcion_modulos.findFirst.mock.calls[0][0].where).toMatchObject({
      activo: true,
      suscripciones: { empresa_id: 'emp-1', estado: { in: ['Activo', 'EnGracia'] } },
      modulos: { codigo: 'INVENTARIO', active: true },
    });
    expect(prisma.perfiles_privilegios.findFirst.mock.calls[0][0].where).toMatchObject({
      active: true,
      modulos: { codigo: 'INVENTARIO' },
      privilegios: { codigo: 'INV_DEP_DEPOSITO_VER' },
      perfiles: { usuario_perfiles: { some: { user_id: 'u-1' } } },
    });
  });

  it('sin el privilegio → no', async () => {
    await expect(tienePermiso(prismaCon({ privilegio: false }) as never, usuario, 'INVENTARIO', 'INV_DEP_DEPOSITO_VER')).resolves.toBe(false);
  });

  it('sin el módulo en la suscripción → no, aunque sea superadmin', async () => {
    await expect(tienePermiso(prismaCon({ moduloActivo: false }) as never, usuario, 'INVENTARIO', 'INV_DEP_DEPOSITO_VER')).resolves.toBe(false);
    await expect(tienePermiso(prismaCon({ moduloActivo: false, superadmin: true }) as never, usuario, 'INVENTARIO', 'INV_DEP_DEPOSITO_VER')).resolves.toBe(false);
  });

  it('privilegio de un addon no contratado → no; contratado → sí', async () => {
    await expect(tienePermiso(prismaCon({ addon: { es_addon: true, contratado: false } }) as never, usuario, 'INVENTARIO', 'INV_DEP_DEPOSITO_VER')).resolves.toBe(false);
    await expect(tienePermiso(prismaCon({ addon: { es_addon: true, contratado: true } }) as never, usuario, 'INVENTARIO', 'INV_DEP_DEPOSITO_VER')).resolves.toBe(true);
  });

  it('superadmin con el módulo → sí sin mirar perfiles; holding sin suscripción → decide el privilegio', async () => {
    const admin = prismaCon({ superadmin: true, privilegio: false });
    await expect(tienePermiso(admin as never, usuario, 'INVENTARIO', 'INV_DEP_DEPOSITO_VER')).resolves.toBe(true);
    expect(admin.perfiles_privilegios.findFirst).not.toHaveBeenCalled();
    const holding = prismaCon({ tipoEmpresa: 'holding', moduloActivo: false });
    await expect(tienePermiso(holding as never, usuario, 'INVENTARIO', 'INV_DEP_DEPOSITO_VER')).resolves.toBe(true);
    expect(holding.suscripcion_modulos.findFirst).not.toHaveBeenCalled();
  });

  it('sin usuario o sin empresa → no, sin consultar', async () => {
    const prisma = prismaCon();
    await expect(tienePermiso(prisma as never, { id: undefined, empresa_id: 'emp-1' }, 'INVENTARIO', 'INV_DEP_DEPOSITO_VER')).resolves.toBe(false);
    await expect(tienePermiso(prisma as never, { id: 'u-1', empresa_id: undefined }, 'INVENTARIO', 'INV_DEP_DEPOSITO_VER')).resolves.toBe(false);
    expect(prisma.usuario.findUnique).not.toHaveBeenCalled();
  });
});

describe('GET /sucursales/:id/detalle — depósitos solo con INVENTARIO · INV_DEP_DEPOSITO_VER', () => {
  it('con el permiso trae los depósitos', async () => {
    const prisma = prismaCon();
    const { data } = await servicio(prisma).findOneWithRelations('suc-1', 'emp-1', 'u-1');
    expect(prisma.empresas_sucursales.findFirst.mock.calls[0][0].include.depositos).toBe(true);
    expect(data).toMatchObject({ depositos: [{ id: 'dep-1' }] });
  });

  it('sin el privilegio de depósitos no los pide ni los devuelve', async () => {
    const prisma = prismaCon({ privilegio: false });
    const { data } = await servicio(prisma).findOneWithRelations('suc-1', 'emp-1', 'u-1');
    expect(prisma.empresas_sucursales.findFirst.mock.calls[0][0].include.depositos).toBe(false);
    expect(data).not.toHaveProperty('depositos');
  });

  it('sin INVENTARIO en el plan tampoco', async () => {
    const prisma = prismaCon({ moduloActivo: false });
    const { data } = await servicio(prisma).findOneWithRelations('suc-1', 'emp-1', 'u-1');
    expect(data).not.toHaveProperty('depositos');
  });

  it('el controller pasa el usuario del token', async () => {
    const service = { findOneWithRelations: jest.fn().mockResolvedValue({}) };
    const controller = new SucursalesController(service as never);
    await controller.findOneWithRelations('suc-1', { id: 'u-1', empresa_id: 'emp-1' } as never);
    expect(service.findOneWithRelations).toHaveBeenCalledWith('suc-1', 'emp-1', 'u-1');
  });
});
