import { ExecutionContext, ForbiddenException } from '@nestjs/common';
import { correrConRubro } from 'src/utils/rubro-context';
import { AlcanceTotalGuard, CODIGO_IA_REQUIERE_ALCANCE_TOTAL, CODIGO_IA_SOLO_PROPIO } from './alcance-total.guard';

/**
 * La IA (resumen, métricas, alertas, predicciones, timeline y chat) mira la empresa entera. Solo la usa quien ve la
 * empresa entera (`esAlcanceTotal`, F1): sin restricción, o asignado a todas las sucursales activas, y sin un rubro
 * elegido. Un usuario limitado a una sucursal, o mirando un rubro, recibe 403 `IA_REQUIERE_ALCANCE_TOTAL`.
 * Además (A2, regla estricta) hace falta `REP_DSH_VER_TODO`: el mock lo da por defecto (`verTodo = true`) para que los
 * casos de sucursal/rubro miren solo eso; los de alcance propio lo apagan.
 */
describe('AlcanceTotalGuard', () => {
  const crearPrisma = ({
    superadmin = false,
    asignadas = [] as string[],
    activas = ['s1', 's2'],
    vinculos = [] as Array<{ id: string; tipo: string }>,
    verTodo = true,
  } = {}) =>
    ({
      usuario: { findUnique: jest.fn().mockResolvedValue({ is_superadmin: superadmin }) },
      empresas: { findUnique: jest.fn().mockResolvedValue({ type: 'subsidiary' }) },
      rubros: { findFirst: jest.fn().mockResolvedValue({ id: 'rubro-1' }) },
      asignacion_sucursal_caja_usuario: {
        findMany: jest.fn().mockResolvedValue(asignadas.map((id) => ({ sucursal_id: id }))),
        count: jest.fn().mockResolvedValue(asignadas.length),
      },
      empresas_sucursales: {
        findMany: jest.fn(({ where }) => {
          let ids = activas;
          if (where?.id?.in) ids = ids.filter((id) => where.id.in.includes(id));
          return Promise.resolve(ids.map((id) => ({ id, punto_establecimiento: '001', config: null })));
        }),
      },
      depositos: { findMany: jest.fn().mockResolvedValue([]) },
      vendedores_cobradores: {
        findMany: jest.fn().mockResolvedValue(vinculos.map((v) => ({ ...v, nombre: 'Ana', apellido: null }))),
      },
      perfiles_privilegios: { findFirst: jest.fn().mockResolvedValue(verTodo ? { id: 'pp' } : null) },
    }) as any;

  const contexto = (user: any = { id: 'usr', empresa_id: 'emp' }) =>
    ({ switchToHttp: () => ({ getRequest: () => ({ user }) }) }) as unknown as ExecutionContext;

  const errorDe = async (p: Promise<unknown>) => {
    try {
      await p;
    } catch (e) {
      return e;
    }
    throw new Error('se esperaba un 403');
  };

  it('sin restricción (alcance null: sin asignaciones) pasa', async () => {
    const guard = new AlcanceTotalGuard(crearPrisma());
    await expect(guard.canActivate(contexto())).resolves.toBe(true);
  });

  it('superadmin pasa', async () => {
    const guard = new AlcanceTotalGuard(crearPrisma({ superadmin: true }));
    await expect(guard.canActivate(contexto())).resolves.toBe(true);
  });

  it('asignado a todas las sucursales activas pasa (F1)', async () => {
    const guard = new AlcanceTotalGuard(crearPrisma({ asignadas: ['s1', 's2'] }));
    await expect(guard.canActivate(contexto())).resolves.toBe(true);
  });

  it('limitado a una sucursal ({ sucursalIds: ["s1"] }) da 403 IA_REQUIERE_ALCANCE_TOTAL', async () => {
    const guard = new AlcanceTotalGuard(crearPrisma({ asignadas: ['s1'] }));
    const e: any = await errorDe(guard.canActivate(contexto()));
    expect(e).toBeInstanceOf(ForbiddenException);
    expect(e.getResponse()).toEqual({ message: expect.any(String), codigo: CODIGO_IA_REQUIERE_ALCANCE_TOTAL });
    expect(CODIGO_IA_REQUIERE_ALCANCE_TOTAL).toBe('IA_REQUIERE_ALCANCE_TOTAL');
  });

  it('con un rubro de la empresa elegido da 403 aunque el usuario vea todo', async () => {
    const guard = new AlcanceTotalGuard(crearPrisma({ superadmin: true }));
    const e: any = await errorDe(correrConRubro('rubro-1', () => guard.canActivate(contexto())));
    expect(e).toBeInstanceOf(ForbiddenException);
    expect(e.getResponse().codigo).toBe(CODIGO_IA_REQUIERE_ALCANCE_TOTAL);
  });

  it('sin usuario en el request da 403', async () => {
    const guard = new AlcanceTotalGuard(crearPrisma());
    await expect(guard.canActivate(contexto(null))).rejects.toBeInstanceOf(ForbiddenException);
  });

  describe('alcance propio (Tablero «lo mío»): sin REP_DSH_VER_TODO, vinculado o no', () => {
    it('ve toda la empresa pero está en alcance propio: 403 IA_SOLO_PROPIO', async () => {
      const guard = new AlcanceTotalGuard(crearPrisma({ vinculos: [{ id: 'vc', tipo: 'vendedor' }], verTodo: false }));
      const e: any = await errorDe(guard.canActivate(contexto()));
      expect(e).toBeInstanceOf(ForbiddenException);
      expect(e.getResponse()).toEqual({ message: expect.any(String), codigo: CODIGO_IA_SOLO_PROPIO });
      expect(CODIGO_IA_SOLO_PROPIO).toBe('IA_SOLO_PROPIO');
    });

    it('alcance propio y además limitado a una sucursal: el motivo es IA_SOLO_PROPIO (va primero)', async () => {
      const guard = new AlcanceTotalGuard(
        crearPrisma({ asignadas: ['s1'], vinculos: [{ id: 'vc', tipo: 'cobrador' }], verTodo: false }),
      );
      const e: any = await errorDe(guard.canActivate(contexto()));
      expect(e.getResponse().codigo).toBe(CODIGO_IA_SOLO_PROPIO);
    });

    it('vinculado con REP_DSH_VER_TODO en un perfil de la empresa: pasa', async () => {
      const guard = new AlcanceTotalGuard(crearPrisma({ vinculos: [{ id: 'vc', tipo: 'ambos' }], verTodo: true }));
      await expect(guard.canActivate(contexto())).resolves.toBe(true);
    });

    it('superadmin vinculado: pasa', async () => {
      const guard = new AlcanceTotalGuard(
        crearPrisma({ superadmin: true, vinculos: [{ id: 'vc', tipo: 'vendedor' }], verTodo: false }),
      );
      await expect(guard.canActivate(contexto())).resolves.toBe(true);
    });

    it('sin vínculo y sin REP_DSH_VER_TODO, aunque vea toda la empresa: 403 IA_SOLO_PROPIO', async () => {
      const guard = new AlcanceTotalGuard(crearPrisma({ verTodo: false }));
      const e: any = await errorDe(guard.canActivate(contexto()));
      expect(e).toBeInstanceOf(ForbiddenException);
      expect(e.getResponse()).toEqual({ message: expect.any(String), codigo: CODIGO_IA_SOLO_PROPIO });
    });

    it('sin vínculo con REP_DSH_VER_TODO: pasa (y sigue el control de sucursal)', async () => {
      await expect(new AlcanceTotalGuard(crearPrisma()).canActivate(contexto())).resolves.toBe(true);
      const e: any = await errorDe(new AlcanceTotalGuard(crearPrisma({ asignadas: ['s1'] })).canActivate(contexto()));
      expect(e.getResponse().codigo).toBe(CODIGO_IA_REQUIERE_ALCANCE_TOTAL);
    });

    it('superadmin sin vínculo ni VER_TODO: pasa', async () => {
      const guard = new AlcanceTotalGuard(crearPrisma({ superadmin: true, verTodo: false }));
      await expect(guard.canActivate(contexto())).resolves.toBe(true);
    });
  });
});
