import {
  ConflictException,
  ForbiddenException,
  UnauthorizedException,
} from '@nestjs/common';
import { JwtService } from '@nestjs/jwt';
import { Test, TestingModule } from '@nestjs/testing';
import * as bcrypt from 'bcrypt';
import { beforeEach, describe, expect, it, vi } from 'vitest';
import { APP_CONFIG } from '../config/app.config.js';
import { PrismaService } from '../prisma/prisma.service.js';
import { AuthService } from './auth.service.js';

vi.mock('bcrypt', () => ({
  hash: vi.fn(),
  compare: vi.fn(),
}));

type UserRow = {
  id: string;
  firstName: string;
  lastName: string;
  email: string;
  passwordHash: string;
  role: 'ADMIN' | 'SALES_USER';
  isActive: boolean;
  createdAt: Date;
  updatedAt: Date;
};

describe('AuthService', () => {
  let service: AuthService;
  let prisma: {
    db: {
      orm: {
        public: {
          User: {
            where: ReturnType<typeof vi.fn>;
            select: ReturnType<typeof vi.fn>;
          };
        };
      };
    };
  };
  let jwtService: { signAsync: ReturnType<typeof vi.fn> };
  let config: {
    allowPublicRegistration: boolean;
    bcryptRounds: number;
  };

  const now = new Date('2026-01-01T00:00:00.000Z');
  const safeUserFields = {
    id: 'user-1',
    firstName: 'Ada',
    lastName: 'Lovelace',
    email: 'ada@example.com',
    role: 'SALES_USER' as const,
    isActive: true,
    createdAt: now,
    updatedAt: now,
  };

  const fullUser: UserRow = {
    ...safeUserFields,
    passwordHash: 'hashed-password',
  };

  beforeEach(async () => {
    vi.clearAllMocks();

    const create = vi.fn();
    const selectChain = {
      create,
      where: vi.fn(),
    };

    const first = vi.fn();
    const whereChain = {
      first,
    };

    prisma = {
      db: {
        orm: {
          public: {
            User: {
              where: vi.fn().mockReturnValue(whereChain),
              select: vi.fn().mockReturnValue(selectChain),
            },
          },
        },
      },
    };

    jwtService = {
      signAsync: vi.fn().mockResolvedValue('signed-jwt-token'),
    };

    config = {
      allowPublicRegistration: true,
      bcryptRounds: 10,
    };

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

    service = module.get(AuthService);
  });

  it('registers a new user with hashed password and default role', async () => {
    prisma.db.orm.public.User.where().first.mockResolvedValue(null);
    vi.mocked(bcrypt.hash).mockResolvedValue('hashed-password' as never);
    prisma.db.orm.public.User.select().create.mockResolvedValue(safeUserFields);

    const result = await service.register({
      firstName: ' Ada ',
      lastName: ' Lovelace ',
      email: ' Ada@Example.com ',
      password: 'password123',
    });

    expect(bcrypt.hash).toHaveBeenCalledWith('password123', 10);
    expect(prisma.db.orm.public.User.select().create).toHaveBeenCalledWith({
      firstName: 'Ada',
      lastName: 'Lovelace',
      email: 'ada@example.com',
      passwordHash: 'hashed-password',
      role: 'SALES_USER',
      isActive: true,
    });
    expect(result).toEqual(safeUserFields);
    expect(result).not.toHaveProperty('passwordHash');
  });

  it('rejects public registration when disabled', async () => {
    config.allowPublicRegistration = false;

    await expect(
      service.register({
        firstName: 'Ada',
        lastName: 'Lovelace',
        email: 'ada@example.com',
        password: 'password123',
      }),
    ).rejects.toBeInstanceOf(ForbiddenException);
  });

  it('rejects duplicate email registration', async () => {
    prisma.db.orm.public.User.where().first.mockResolvedValue(fullUser);

    await expect(
      service.register({
        firstName: 'Ada',
        lastName: 'Lovelace',
        email: 'ada@example.com',
        password: 'password123',
      }),
    ).rejects.toBeInstanceOf(ConflictException);
  });

  it('logs in with valid credentials and returns a JWT', async () => {
    prisma.db.orm.public.User.where().first.mockResolvedValue(fullUser);
    vi.mocked(bcrypt.compare).mockResolvedValue(true as never);

    const result = await service.login({
      email: 'ADA@example.com',
      password: 'password123',
    });

    expect(bcrypt.compare).toHaveBeenCalledWith(
      'password123',
      'hashed-password',
    );
    expect(jwtService.signAsync).toHaveBeenCalledWith({
      sub: 'user-1',
      email: 'ada@example.com',
      role: 'SALES_USER',
    });
    expect(result).toEqual({
      accessToken: 'signed-jwt-token',
      user: safeUserFields,
    });
    expect(result.user).not.toHaveProperty('passwordHash');
  });

  it('rejects login with wrong password', async () => {
    prisma.db.orm.public.User.where().first.mockResolvedValue(fullUser);
    vi.mocked(bcrypt.compare).mockResolvedValue(false as never);

    await expect(
      service.login({
        email: 'ada@example.com',
        password: 'wrong-password',
      }),
    ).rejects.toBeInstanceOf(UnauthorizedException);
  });

  it('rejects login for inactive users', async () => {
    prisma.db.orm.public.User.where().first.mockResolvedValue({
      ...fullUser,
      isActive: false,
    });

    await expect(
      service.login({
        email: 'ada@example.com',
        password: 'password123',
      }),
    ).rejects.toBeInstanceOf(UnauthorizedException);
    expect(bcrypt.compare).not.toHaveBeenCalled();
  });

  it('returns null for inactive users when resolving by id', async () => {
    const first = vi.fn().mockResolvedValue({
      ...safeUserFields,
      isActive: false,
    });
    prisma.db.orm.public.User.select().where = vi
      .fn()
      .mockReturnValue({ first });

    const result = await service.findActiveSafeUserById('user-1');
    expect(result).toBeNull();
  });
});
