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 { UsersController } from './users.controller.js';
import { UsersService } from './users.service.js';

describe('UsersController', () => {
  let controller: UsersController;
  let usersService: {
    create: ReturnType<typeof vi.fn>;
    findAll: ReturnType<typeof vi.fn>;
    listAssignees: ReturnType<typeof vi.fn>;
    findOne: ReturnType<typeof vi.fn>;
    update: ReturnType<typeof vi.fn>;
    updateStatus: 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'),
  };

  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 () => {
    usersService = {
      create: vi.fn().mockResolvedValue(admin),
      findAll: vi.fn().mockResolvedValue({
        data: [admin],
        meta: { total: 1, page: 1, limit: 20, totalPages: 1 },
      }),
      listAssignees: vi.fn().mockResolvedValue({
        data: [admin, sales],
        meta: { total: 2, page: 1, limit: 20, totalPages: 1 },
      }),
      findOne: vi.fn().mockResolvedValue(admin),
      update: vi.fn().mockResolvedValue(admin),
      updateStatus: vi.fn().mockResolvedValue({ ...admin, isActive: false }),
    };

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

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

  it('lists users', async () => {
    const query = { page: 1, limit: 20 };
    await expect(controller.findAll(query)).resolves.toEqual({
      data: [admin],
      meta: { total: 1, page: 1, limit: 20, totalPages: 1 },
    });
    expect(usersService.findAll).toHaveBeenCalledWith(query);
  });

  it('lists assignees for lead assignment', async () => {
    const query = { page: 1, limit: 20 };
    await expect(controller.listAssignees(query)).resolves.toEqual({
      data: [admin, sales],
      meta: { total: 2, page: 1, limit: 20, totalPages: 1 },
    });
    expect(usersService.listAssignees).toHaveBeenCalledWith(query);
  });

  it('creates a user', async () => {
    const dto = {
      firstName: 'Sales',
      lastName: 'User',
      email: 'sales@example.com',
      password: 'password123',
    };
    await expect(controller.create(dto)).resolves.toEqual(admin);
    expect(usersService.create).toHaveBeenCalledWith(dto);
  });

  it('gets a user by id', async () => {
    await expect(controller.findOne('admin-1')).resolves.toEqual(admin);
    expect(usersService.findOne).toHaveBeenCalledWith('admin-1');
  });

  it('updates a user', async () => {
    const dto = { firstName: 'Updated' };
    await expect(controller.update('admin-1', dto)).resolves.toEqual(admin);
    expect(usersService.update).toHaveBeenCalledWith('admin-1', dto);
  });

  it('updates the signed-in user profile', async () => {
    const dto = { firstName: 'Updated' };
    await expect(controller.updateProfile(sales, dto)).resolves.toEqual(admin);
    expect(usersService.update).toHaveBeenCalledWith(sales.id, dto);
  });

  it('updates user status', async () => {
    const dto = { isActive: false };
    await expect(controller.updateStatus('admin-1', dto)).resolves.toEqual({
      ...admin,
      isActive: false,
    });
    expect(usersService.updateStatus).toHaveBeenCalledWith('admin-1', dto);
  });
});

describe('Users 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'),
  };

  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 () => {
    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 on user-management endpoints', () => {
    reflector.getAllAndOverride.mockReturnValue(['ADMIN']);
    expect(guard.canActivate(createContext(admin) as never)).toBe(true);
  });

  it('rejects SALES_USER on user-management endpoints', () => {
    reflector.getAllAndOverride.mockReturnValue(['ADMIN']);
    expect(() => guard.canActivate(createContext(sales) as never)).toThrow(
      ForbiddenException,
    );
  });

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