jest.mock('./guards/algun-privilegio.guard', () => ({
  ...jest.requireActual('./guards/algun-privilegio.guard'),
  tieneAlgunPrivilegio: jest.fn(),
}));

import { AuthService } from './auth.service';
import { tieneAlgunPrivilegio } from './guards/algun-privilegio.guard';
import {
  PRIVILEGIOS_PAGAR_SUSCRIPCION,
  PRIVILEGIOS_VER_PAGOS_SUSCRIPCION,
} from 'src/suscripciones/privilegios-suscripcion';

/**
 * Carril 0 de Configuración › `/auth/me` le da al front los datos de acceso que hoy adivina:
 * - `user.es_admin_plataforma`: la marca de la plataforma (no el `is_superadmin` del dueño).
 * - `acceso_suscripcion`: lo mismo que piden las rutas de `/suscripciones` (mismas constantes), sin mirar si la
 *   suscripción está bloqueada (una empresa bloqueada tiene que poder ver lo que debe y pagar).
 */
const tiene = tieneAlgunPrivilegio as jest.MockedFunction<typeof tieneAlgunPrivilegio>;

const usuario = (marca: Partial<{ is_superadmin: boolean; es_admin_plataforma: boolean }>) => ({
  id: 'u1',
  username: 'u',
  nombres: 'N',
  apellidos: 'A',
  email: null,
  is_superadmin: false,
  es_admin_plataforma: false,
  empresa_id: 'e1',
  empresa_id_actual: 'e1',
  empresa_rel: { id: 'e1', razon_social: 'E', nombre_fantasia: null, ruc: '1', dv: '1', type: 'subsidiary', sifen_activo: false },
  usuario_perfiles: [],
  ...marca,
});

const auth = (u: any, estado = { activa: true, bloqueada: false, razon: null as string | null }) => {
  const s = Object.create(AuthService.prototype) as any;
  s.prisma = {
    usuario: { findUnique: jest.fn().mockResolvedValue(u) },
    suscripciones: { findFirst: jest.fn().mockResolvedValue(null) },
    empresas: { findUnique: jest.fn().mockResolvedValue(null) },
    privilegios: { findMany: jest.fn().mockResolvedValue([]) },
  };
  s.suscripcionesService = {
    getSubmodulosActivos: jest.fn().mockResolvedValue([]),
    verificarEstadoSuscripcion: jest.fn().mockResolvedValue(estado),
  };
  s.rubrosService = { contextoDeUsuario: jest.fn().mockResolvedValue({ sucursal_default_id: null }) };
  return s;
};

beforeEach(() => {
  tiene.mockReset();
  tiene.mockResolvedValue(false);
});

describe('GET /auth/me › es_admin_plataforma', () => {
  it('con la marca de plataforma → true', async () => {
    const s = auth(usuario({ is_superadmin: true, es_admin_plataforma: true }));
    const r = await s.getMe('u1', 'e1');
    expect(r.user.es_admin_plataforma).toBe(true);
    const select = s.prisma.usuario.findUnique.mock.calls[0][0].select;
    expect(select.es_admin_plataforma).toBe(true);
  });

  it('dueño (is_superadmin) sin la marca → false', async () => {
    const r = await auth(usuario({ is_superadmin: true, es_admin_plataforma: false })).getMe('u1', 'e1');
    expect(r.user.is_superadmin).toBe(true);
    expect(r.user.es_admin_plataforma).toBe(false);
  });

  it('empresa_principal_id: la empresa del usuario (no la activa), para saber si es dueño de la que opera', async () => {
    const r = await auth({ ...usuario({ is_superadmin: true }), empresa_id: 'holding-1', empresa_id_actual: 'e1' }).getMe('u1', 'e1');
    expect((r.user as any).empresa_principal_id).toBe('holding-1');
  });
});

describe('GET /auth/me › acceso_suscripcion', () => {
  it('consulta las mismas constantes que las rutas y devuelve sus resultados', async () => {
    tiene.mockImplementation(async (_p, _u, codigos) => codigos === PRIVILEGIOS_VER_PAGOS_SUSCRIPCION);
    const s = auth(usuario({}));
    const r = await s.getMe('u1', 'e1');
    expect(tiene).toHaveBeenCalledWith(s.prisma, 'u1', PRIVILEGIOS_VER_PAGOS_SUSCRIPCION);
    expect(tiene).toHaveBeenCalledWith(s.prisma, 'u1', PRIVILEGIOS_PAGAR_SUSCRIPCION);
    expect(r.acceso_suscripcion).toEqual({ ver_pagos: true, subir_comprobante: false });
  });

  it('subir_comprobante sale de PRIVILEGIOS_PAGAR_SUSCRIPCION', async () => {
    tiene.mockImplementation(async (_p, _u, codigos) => codigos === PRIVILEGIOS_PAGAR_SUSCRIPCION);
    const r = await auth(usuario({})).getMe('u1', 'e1');
    expect(r.acceso_suscripcion).toEqual({ ver_pagos: false, subir_comprobante: true });
  });

  it('con la suscripción bloqueada responde igual con los dos campos', async () => {
    tiene.mockResolvedValue(true);
    const r = await auth(usuario({}), { activa: false, bloqueada: true, razon: 'vencida' }).getMe('u1', 'e1');
    expect(r.suscripcion.bloqueada).toBe(true);
    expect(r.acceso_suscripcion).toEqual({ ver_pagos: true, subir_comprobante: true });
    expect(r.user.es_admin_plataforma).toBe(false);
  });
});
