import { describe, it, expect, vi, beforeEach } from 'vitest';
import { LoginPageQuery } from './LoginPageQuery';
import { AuthPageService } from '@/lib/services/auth/AuthPageService';
import { Result } from '@/lib/contracts/Result';
import { LoginViewDataBuilder } from '@/lib/builders/view-data/LoginViewDataBuilder';
import { SearchParamParser } from '@/lib/routing/search-params/SearchParamParser';

// Mock dependencies
const mockProcessForgotPasswordParams = vi.fn();
const mockProcessLoginParams = vi.fn();
const mockProcessResetPasswordParams = vi.fn();
const mockProcessSignupParams = vi.fn();
vi.mock('@/lib/services/auth/AuthPageService', () => {
  return {
    AuthPageService: class {
      processForgotPasswordParams = mockProcessForgotPasswordParams;
      processLoginParams = mockProcessLoginParams;
      processResetPasswordParams = mockProcessResetPasswordParams;
      processSignupParams = mockProcessSignupParams;
    },
  };
});

vi.mock('@/lib/routing/search-params/SearchParamParser', () => ({
  SearchParamParser: {
    parseAuth: vi.fn(),
  },
}));

vi.mock('@/lib/builders/view-data/LoginViewDataBuilder', () => ({
  LoginViewDataBuilder: {
    build: vi.fn(),
  },
}));

describe('LoginPageQuery', () => {
  let query: LoginPageQuery;
  let mockServiceInstance: any;
  let mockSearchParams: URLSearchParams;

  beforeEach(() => {
    vi.clearAllMocks();
    mockServiceInstance = {
      processLoginParams: mockProcessLoginParams,
    };
    query = new LoginPageQuery(mockServiceInstance as any);
    mockSearchParams = new URLSearchParams('returnTo=/dashboard&token=abc123');
  });

  it('should return view data when search params are valid and service succeeds', async () => {
    const parsedParams = { returnTo: '/dashboard', token: 'abc123' };
    const serviceOutput = { success: true };
    const viewData = { returnTo: '/dashboard', token: 'abc123' };

    (SearchParamParser.parseAuth as any).mockReturnValue(Result.ok(parsedParams));
    mockServiceInstance.processLoginParams.mockResolvedValue(Result.ok(serviceOutput));
    (LoginViewDataBuilder.build as any).mockReturnValue(viewData);

    const result = await query.execute(mockSearchParams);

    expect(result.isOk()).toBe(true);
    expect(result.unwrap()).toEqual(viewData);
    expect(SearchParamParser.parseAuth).toHaveBeenCalledWith(mockSearchParams);
    expect(mockServiceInstance.processLoginParams).toHaveBeenCalledWith(parsedParams);
    expect(LoginViewDataBuilder.build).toHaveBeenCalledWith(serviceOutput);
  });

  it('should return error when search params are invalid', async () => {
    (SearchParamParser.parseAuth as any).mockReturnValue(Result.err('Invalid params'));

    const result = await query.execute(mockSearchParams);

    expect(result.isErr()).toBe(true);
    expect(result.getError()).toBe('Invalid search parameters: Invalid params');
  });

  it('should return error when service fails', async () => {
    const parsedParams = { returnTo: '/dashboard', token: 'abc123' };

    (SearchParamParser.parseAuth as any).mockReturnValue(Result.ok(parsedParams));
    mockServiceInstance.processLoginParams.mockResolvedValue(
      Result.err({ message: 'Service error' })
    );

    const result = await query.execute(mockSearchParams);

    expect(result.isErr()).toBe(true);
    expect(result.getError()).toBe('Service error');
  });

  it('should return error on exception', async () => {
    const parsedParams = { returnTo: '/dashboard', token: 'abc123' };

    (SearchParamParser.parseAuth as any).mockReturnValue(Result.ok(parsedParams));
    mockServiceInstance.processLoginParams.mockRejectedValue(new Error('Unexpected error'));

    const result = await query.execute(mockSearchParams);

    expect(result.isErr()).toBe(true);
    expect(result.getError()).toBe('Unexpected error');
  });

  it('should provide a static execute method', async () => {
    const parsedParams = { returnTo: '/dashboard', token: 'abc123' };
    const serviceOutput = { success: true };
    const viewData = { returnTo: '/dashboard', token: 'abc123' };

    (SearchParamParser.parseAuth as any).mockReturnValue(Result.ok(parsedParams));
    mockServiceInstance.processLoginParams.mockResolvedValue(Result.ok(serviceOutput));
    (LoginViewDataBuilder.build as any).mockReturnValue(viewData);

    const result = await LoginPageQuery.execute(mockSearchParams);

    expect(result.isOk()).toBe(true);
    expect(result.unwrap()).toEqual(viewData);
  });

  it('should handle Record<string, string | string[] | undefined> input', async () => {
    const recordParams = { returnTo: '/dashboard', token: 'abc123' };
    const parsedParams = { returnTo: '/dashboard', token: 'abc123' };
    const serviceOutput = { success: true };
    const viewData = { returnTo: '/dashboard', token: 'abc123' };

    (SearchParamParser.parseAuth as any).mockReturnValue(Result.ok(parsedParams));
    mockServiceInstance.processLoginParams.mockResolvedValue(Result.ok(serviceOutput));
    (LoginViewDataBuilder.build as any).mockReturnValue(viewData);

    const result = await query.execute(recordParams);

    expect(result.isOk()).toBe(true);
    expect(result.unwrap()).toEqual(viewData);
    expect(SearchParamParser.parseAuth).toHaveBeenCalledWith(recordParams);
  });
});