import { ForbiddenException } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { Test, TestingModule } from '@nestjs/testing';
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard.js';
import { RolesGuard } from '../auth/guards/roles.guard.js';
import type { SafeUser } from '../auth/types/auth.types.js';
import { DashboardController } from './dashboard.controller.js';
import { DashboardService } from './dashboard.service.js';

describe('DashboardController', () => {
  let controller: DashboardController;
  let dashboardService: { getOverview: ReturnType<typeof vi.fn> };

  const admin: SafeUser = {
    id: 'admin-1',
    firstName: 'Admin',
    lastName: 'User',
    email: 'admin@example.com',
    role: 'ADMIN',
    isActive: true,
    createdAt: new Date('2026-01-01T00:00:00.000Z'),
    updatedAt: new Date('2026-01-01T00:00:00.000Z'),
  };

  beforeEach(async () => {
    dashboardService = {
      getOverview: vi.fn().mockResolvedValue({
        summary: {
          leads: 1,
          openLeads: 1,
          wonLeads: 0,
          companies: 1,
          contacts: 1,
        },
        contactsMeaning: 'test',
        pipeline: [],
        recentActivities: [],
        recentLeads: [],
      }),
    };

    const module: TestingModule = await Test.createTestingModule({
      controllers: [DashboardController],
      providers: [{ provide: DashboardService, useValue: dashboardService }],
    })
      .overrideGuard(JwtAuthGuard)
      .useValue({ canActivate: () => true })
      .overrideGuard(RolesGuard)
      .useValue({ canActivate: () => true })
      .compile();

    controller = module.get(DashboardController);
  });

  it('returns dashboard overview for the current user', async () => {
    await expect(controller.getOverview(admin)).resolves.toMatchObject({
      summary: { leads: 1 },
    });
    expect(dashboardService.getOverview).toHaveBeenCalledWith(admin);
  });
});

describe('Dashboard authorization roles', () => {
  let guard: RolesGuard;
  let reflector: { getAllAndOverride: ReturnType<typeof vi.fn> };

  const sales: SafeUser = {
    id: 'sales-1',
    firstName: 'Sales',
    lastName: 'User',
    email: 'sales@example.com',
    role: 'SALES_USER',
    isActive: true,
    createdAt: new Date('2026-01-01T00:00:00.000Z'),
    updatedAt: new Date('2026-01-01T00:00:00.000Z'),
  };

  beforeEach(async () => {
    reflector = { getAllAndOverride: vi.fn() };
    const module: TestingModule = await Test.createTestingModule({
      providers: [RolesGuard, { provide: Reflector, useValue: reflector }],
    }).compile();
    guard = module.get(RolesGuard);
  });

  function createContext(user?: SafeUser) {
    return {
      getHandler: () => ({}),
      getClass: () => ({}),
      switchToHttp: () => ({
        getRequest: () => ({ user }),
      }),
    };
  }

  it('allows ADMIN and SALES_USER on dashboard', () => {
    reflector.getAllAndOverride.mockReturnValue(['ADMIN', 'SALES_USER']);
    expect(guard.canActivate(createContext(sales) as never)).toBe(true);
  });

  it('rejects roles outside ADMIN/SALES_USER', () => {
    reflector.getAllAndOverride.mockReturnValue(['ADMIN']);
    expect(() => guard.canActivate(createContext(sales) as never)).toThrow(
      ForbiddenException,
    );
  });
});
