import { UnauthorizedException } from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import { Test, TestingModule } from '@nestjs/testing';
import { ThrottlerGuard } from '@nestjs/throttler';
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { AuthController } from './auth.controller.js';
import { AuthService } from './auth.service.js';
import { JwtAuthGuard } from './guards/jwt-auth.guard.js';
import type { SafeUser } from './types/auth.types.js';

describe('AuthController', () => {
  let controller: AuthController;
  let authService: {
    register: ReturnType<typeof vi.fn>;
    login: ReturnType<typeof vi.fn>;
  };

  const safeUser: SafeUser = {
    id: 'user-1',
    firstName: 'Ada',
    lastName: 'Lovelace',
    email: 'ada@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 () => {
    authService = {
      register: vi.fn().mockResolvedValue(safeUser),
      login: vi.fn().mockResolvedValue({
        accessToken: 'signed-jwt-token',
        user: safeUser,
      }),
    };

    const module: TestingModule = await Test.createTestingModule({
      controllers: [AuthController],
      providers: [{ provide: AuthService, useValue: authService }],
    })
      .overrideGuard(JwtAuthGuard)
      .useValue({ canActivate: () => true })
      .overrideGuard(ThrottlerGuard)
      .useValue({ canActivate: () => true })
      .compile();

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

  it('registers a user', async () => {
    const dto = {
      firstName: 'Ada',
      lastName: 'Lovelace',
      email: 'ada@example.com',
      password: 'password123',
    };

    await expect(controller.register(dto)).resolves.toEqual(safeUser);
    expect(authService.register).toHaveBeenCalledWith(dto);
  });

  it('logs in a user', async () => {
    const dto = {
      email: 'ada@example.com',
      password: 'password123',
    };

    await expect(controller.login(dto)).resolves.toEqual({
      accessToken: 'signed-jwt-token',
      user: safeUser,
    });
    expect(authService.login).toHaveBeenCalledWith(dto);
  });

  it('returns the current authenticated user', async () => {
    await expect(controller.me(safeUser)).resolves.toEqual(safeUser);
  });
});

describe('JwtAuthGuard', () => {
  let guard: JwtAuthGuard;
  let jwtService: { verifyAsync: ReturnType<typeof vi.fn> };
  let authService: { findActiveSafeUserById: ReturnType<typeof vi.fn> };

  const safeUser: SafeUser = {
    id: 'user-1',
    firstName: 'Ada',
    lastName: 'Lovelace',
    email: 'ada@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 () => {
    jwtService = {
      verifyAsync: vi.fn(),
    };
    authService = {
      findActiveSafeUserById: vi.fn(),
    };

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

    guard = module.get(JwtAuthGuard);
  });

  function createContext(authorization?: string) {
    const request: {
      headers: { authorization?: string };
      user?: SafeUser;
    } = {
      headers: { authorization },
    };

    return {
      switchToHttp: () => ({
        getRequest: () => request,
      }),
      request,
    };
  }

  it('rejects requests without a JWT', async () => {
    const ctx = createContext();

    await expect(guard.canActivate(ctx as never)).rejects.toBeInstanceOf(
      UnauthorizedException,
    );
  });

  it('allows requests with a valid JWT and attaches the user', async () => {
    const ctx = createContext('Bearer valid-token');
    jwtService.verifyAsync.mockResolvedValue({
      sub: 'user-1',
      email: 'ada@example.com',
      role: 'SALES_USER',
    });
    authService.findActiveSafeUserById.mockResolvedValue(safeUser);

    await expect(guard.canActivate(ctx as never)).resolves.toBe(true);
    expect(ctx.request.user).toEqual(safeUser);
    expect(jwtService.verifyAsync).toHaveBeenCalledWith('valid-token');
  });

  it('rejects invalid JWTs', async () => {
    const ctx = createContext('Bearer bad-token');
    jwtService.verifyAsync.mockRejectedValue(new Error('invalid'));

    await expect(guard.canActivate(ctx as never)).rejects.toBeInstanceOf(
      UnauthorizedException,
    );
  });
});
