/**
 * Mock OAuth Provider Responses for Testing
 *
 * This file provides mock responses for GitHub and Google OAuth providers
 * to enable testing without making real HTTP requests to OAuth providers.
 */

export interface MockOAuthProfile {
  id: string;
  email: string;
  name?: string;
  avatarUrl?: string;
  raw: any;
}

export interface MockOAuthTokens {
  accessToken: string;
  refreshToken?: string;
  expiresIn?: number;
  scope?: string;
}

/**
 * Create a mock GitHub OAuth profile for testing
 */
export function createMockGitHubProfile(overrides?: Partial<MockOAuthProfile>): MockOAuthProfile {
  return {
    id: '12345678',
    email: 'testuser@example.com',
    name: 'Test User',
    avatarUrl: 'https://avatars.githubusercontent.com/u/12345678',
    raw: {
      login: 'testuser',
      id: 12345678,
      node_id: 'MDQ6VXNlcjEyMzQ1Njc4',
      avatar_url: 'https://avatars.githubusercontent.com/u/12345678',
      gravatar_id: '',
      url: 'https://api.github.com/users/testuser',
      html_url: 'https://github.com/testuser',
      type: 'User',
      name: 'Test User',
      email: 'testuser@example.com',
      bio: 'Software Developer',
      location: 'San Francisco',
      created_at: '2015-01-01T00:00:00Z',
      updated_at: '2025-01-01T00:00:00Z'
    },
    ...overrides
  };
}

/**
 * Create a mock Google OAuth profile for testing
 */
export function createMockGoogleProfile(overrides?: Partial<MockOAuthProfile>): MockOAuthProfile {
  return {
    id: '123456789012345678901',
    email: 'testuser@gmail.com',
    name: 'Test User',
    avatarUrl: 'https://lh3.googleusercontent.com/a/default-user',
    raw: {
      id: '123456789012345678901',
      email: 'testuser@gmail.com',
      verified_email: true,
      name: 'Test User',
      given_name: 'Test',
      family_name: 'User',
      picture: 'https://lh3.googleusercontent.com/a/default-user',
      locale: 'en'
    },
    ...overrides
  };
}

/**
 * Create a generic mock OAuth profile for testing
 */
export function createMockOAuthProfile(provider: 'github' | 'google', overrides?: Partial<MockOAuthProfile>): MockOAuthProfile {
  if (provider === 'github') {
    return createMockGitHubProfile(overrides);
  } else {
    return createMockGoogleProfile(overrides);
  }
}

/**
 * Create a mock OAuth token response for testing
 */
export function createMockTokenResponse(overrides?: Partial<MockOAuthTokens>): MockOAuthTokens {
  return {
    accessToken: 'mock_access_token_' + Math.random().toString(36).substring(7),
    refreshToken: 'mock_refresh_token_' + Math.random().toString(36).substring(7),
    expiresIn: 3600,
    scope: 'user:email',
    ...overrides
  };
}

/**
 * Create a mock GitHub token response
 */
export function createMockGitHubTokenResponse(overrides?: Partial<MockOAuthTokens>): MockOAuthTokens {
  return createMockTokenResponse({
    scope: 'user:email',
    ...overrides
  });
}

/**
 * Create a mock Google token response
 */
export function createMockGoogleTokenResponse(overrides?: Partial<MockOAuthTokens>): MockOAuthTokens {
  return createMockTokenResponse({
    scope: 'openid email profile',
    expiresIn: 3600,
    ...overrides
  });
}

/**
 * Mock HTTP response for provider API calls
 */
export class MockHttpResponse {
  public statusCode: number;
  public headers: Record<string, string>;
  public body: string;

  constructor(statusCode: number, body: any, headers: Record<string, string> = {}) {
    this.statusCode = statusCode;
    this.headers = headers;
    this.body = typeof body === 'string' ? body : JSON.stringify(body);
  }

  static success(body: any): MockHttpResponse {
    return new MockHttpResponse(200, body, { 'content-type': 'application/json' });
  }

  static error(statusCode: number, message: string): MockHttpResponse {
    return new MockHttpResponse(statusCode, { error: message }, { 'content-type': 'application/json' });
  }
}

/**
 * Mock GitHub OAuth API responses
 */
export const mockGitHubAPI = {
  tokenExchange: (code: string): MockHttpResponse => {
    if (code === 'invalid_code') {
      return MockHttpResponse.error(400, 'bad_verification_code');
    }
    return MockHttpResponse.success({
      access_token: 'gho_' + Math.random().toString(36).substring(7),
      token_type: 'bearer',
      scope: 'user:email'
    });
  },

  userProfile: (accessToken: string): MockHttpResponse => {
    if (accessToken.startsWith('invalid_')) {
      return MockHttpResponse.error(401, 'Bad credentials');
    }
    return MockHttpResponse.success(createMockGitHubProfile().raw);
  }
};

/**
 * Mock Google OAuth API responses
 */
export const mockGoogleAPI = {
  tokenExchange: (code: string): MockHttpResponse => {
    if (code === 'invalid_code') {
      return MockHttpResponse.error(400, 'invalid_grant');
    }
    return MockHttpResponse.success({
      access_token: 'ya29.' + Math.random().toString(36).substring(7),
      expires_in: 3600,
      scope: 'openid email profile',
      token_type: 'Bearer',
      id_token: 'eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...'
    });
  },

  userProfile: (accessToken: string): MockHttpResponse => {
    if (accessToken.startsWith('invalid_')) {
      return MockHttpResponse.error(401, 'Invalid Credentials');
    }
    return MockHttpResponse.success(createMockGoogleProfile().raw);
  }
};