import { ForbiddenException, UnauthorizedException } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import { JwtService } from '@nestjs/jwt';
import { Test, TestingModule } from '@nestjs/testing';
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { AuthService } from '../auth/auth.service.js';
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 { CompaniesController } from './companies.controller.js';
import { CompaniesService } from './companies.service.js';
import type { CompanyResponse } from './types/company.types.js';

describe('CompaniesController', () => {
  let controller: CompaniesController;
  let companiesService: {
    create: ReturnType<typeof vi.fn>;
    findAll: ReturnType<typeof vi.fn>;
    findOne: ReturnType<typeof vi.fn>;
    update: ReturnType<typeof vi.fn>;
    remove: ReturnType<typeof vi.fn>;
  };

  const company: CompanyResponse = {
    id: 'company-1',
    name: 'Acme Corp',
    domain: null,
    website: null,
    industry: null,
    phone: null,
    email: null,
    address: null,
    createdAt: new Date('2026-01-01T00:00:00.000Z'),
    updatedAt: new Date('2026-01-01T00:00:00.000Z'),
  };

  beforeEach(async () => {
    companiesService = {
      create: vi.fn().mockResolvedValue(company),
      findAll: vi.fn().mockResolvedValue({
        data: [company],
        meta: { total: 1, page: 1, limit: 20, totalPages: 1 },
      }),
      findOne: vi.fn().mockResolvedValue(company),
      update: vi.fn().mockResolvedValue(company),
      remove: vi.fn().mockResolvedValue(undefined),
    };

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

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

  it('creates a company', async () => {
    const dto = { name: 'Acme Corp' };
    await expect(controller.create(dto)).resolves.toEqual(company);
    expect(companiesService.create).toHaveBeenCalledWith(dto);
  });

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

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

  it('updates a company', async () => {
    const dto = { name: 'Updated' };
    await expect(controller.update('company-1', dto)).resolves.toEqual(
      company,
    );
    expect(companiesService.update).toHaveBeenCalledWith('company-1', dto);
  });

  it('deletes a company', async () => {
    await expect(controller.remove('company-1')).resolves.toBeUndefined();
    expect(companiesService.remove).toHaveBeenCalledWith('company-1');
  });
});

describe('Companies authorization', () => {
  let rolesGuard: RolesGuard;
  let jwtGuard: JwtAuthGuard;
  let reflector: { getAllAndOverride: ReturnType<typeof vi.fn> };
  let jwtService: { verifyAsync: ReturnType<typeof vi.fn> };
  let authService: { findActiveSafeUserById: 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() };
    jwtService = { verifyAsync: vi.fn() };
    authService = { findActiveSafeUserById: vi.fn() };

    const rolesModule = await Test.createTestingModule({
      providers: [RolesGuard, { provide: Reflector, useValue: reflector }],
    }).compile();
    rolesGuard = rolesModule.get(RolesGuard);

    const jwtModule = await Test.createTestingModule({
      providers: [
        JwtAuthGuard,
        { provide: JwtService, useValue: jwtService },
        { provide: AuthService, useValue: authService },
      ],
    }).compile();
    jwtGuard = jwtModule.get(JwtAuthGuard);
  });

  it('rejects unauthorized requests without JWT', async () => {
    const context = {
      switchToHttp: () => ({
        getRequest: () => ({
          headers: {},
        }),
      }),
    };

    await expect(
      jwtGuard.canActivate(context as never),
    ).rejects.toBeInstanceOf(UnauthorizedException);
  });

  it('rejects sales users from deleting companies', () => {
    reflector.getAllAndOverride.mockReturnValue(['ADMIN']);
    const context = {
      getHandler: () => ({}),
      getClass: () => ({}),
      switchToHttp: () => ({
        getRequest: () => ({ user: sales }),
      }),
    };

    expect(() => rolesGuard.canActivate(context as never)).toThrow(
      ForbiddenException,
    );
  });
});
