import { describe, it, expect, vi, beforeEach } from 'vitest';
import { authOptions } from '../../app/api/auth/[...nextauth]/route';
import { PrismaClient } from '@prisma/client';
import bcrypt from 'bcryptjs';

// Mock PrismaClient
vi.mock('../../lib/prisma', () => ({
  prisma: new PrismaClient(),
}));

// Mock bcryptjs
vi.mock('bcryptjs', () => ({
  default: {
    compare: vi.fn(),
  },
}));

describe('NextAuth Credentials Provider authorize function', () => {
  let mockFindUnique: vi.Mock;
  let mockBcryptCompare: vi.Mock;

  beforeEach(() => {
    mockFindUnique = vi.fn();
    // @ts-ignore
    prisma.user.findUnique = mockFindUnique;
    mockBcryptCompare = bcrypt.compare as vi.Mock;
    vi.clearAllMocks();
  });

  const authorize = authOptions.providers[0].authorize;

  it('should return null if email or password are not provided', async () => {
    // @ts-ignore
    const result1 = await authorize({ email: 'test@example.com', password: '' });
    expect(result1).toBeNull();
    expect(mockFindUnique).not.toHaveBeenCalled();

    // @ts-ignore
    const result2 = await authorize({ email: '', password: 'password' });
    expect(result2).toBeNull();
    expect(mockFindUnique).not.toHaveBeenCalled();
  });

  it('should return null if user is not found', async () => {
    mockFindUnique.mockResolvedValue(null);

    // @ts-ignore
    const result = await authorize({ email: 'nonexistent@example.com', password: 'password' });
    expect(result).toBeNull();
    expect(mockFindUnique).toHaveBeenCalledWith({
      where: { email: 'nonexistent@example.com' },
    });
    expect(mockBcryptCompare).not.toHaveBeenCalled();
  });

  it('should return null if password does not match', async () => {
    const mockUser = {
      id: 'user123',
      email: 'test@example.com',
      password: 'hashed_password',
      companyId: 'company123',
      role: 'USER',
    };
    mockFindUnique.mockResolvedValue(mockUser);
    mockBcryptCompare.mockResolvedValue(false);

    // @ts-ignore
    const result = await authorize({ email: 'test@example.com', password: 'wrong_password' });
    expect(result).toBeNull();
    expect(mockFindUnique).toHaveBeenCalledWith({
      where: { email: 'test@example.com' },
    });
    expect(mockBcryptCompare).toHaveBeenCalledWith('wrong_password', 'hashed_password');
  });

  it('should return user object if credentials are valid', async () => {
    const mockUser = {
      id: 'user123',
      email: 'test@example.com',
      password: 'hashed_password',
      companyId: 'company123',
      role: 'USER',
    };
    mockFindUnique.mockResolvedValue(mockUser);
    mockBcryptCompare.mockResolvedValue(true);

    // @ts-ignore
    const result = await authorize({ email: 'test@example.com', password: 'correct_password' });
    expect(result).toEqual({
      id: 'user123',
      email: 'test@example.com',
      companyId: 'company123',
      role: 'USER',
    });
    expect(mockFindUnique).toHaveBeenCalledWith({
      where: { email: 'test@example.com' },
    });
    expect(mockBcryptCompare).toHaveBeenCalledWith('correct_password', 'hashed_password');
  });
});