import inquirer from 'inquirer';
import axios from 'axios';
import {
  getAppUrl,
  getSingleSignOnUrl,
  useCluster,
} from '../../helpers/cluserHelper';
import chalk from 'chalk';

export async function requestAuthorizationCode(
  cluster: string,
  username: string,
  password: string,
  clientId: string,
  redirectUri: string,
) {
  try {
    // Step 1: Exchange Authorization Code
    console.log(`${chalk.yellow('...')} Requesting Authorization Code...`);
    var result = await axios.post(
      `https://${getSingleSignOnUrl(cluster)}/api/auth/authorize`,
      {
        username,
        password,
      },
      {
        headers: {
          'X-HSS-CLIENT-ID': clientId,
          'X-HSS-REDIRECT-URI': redirectUri,
          'Content-Type': 'application/json',
        },
      },
    );
    console.log(`${chalk.green('✓')} Authorization Code received`);
    return result?.data as string;
  } catch (error: any) {
    console.error(
      `${chalk.red('✗')} Failed to request authorization code: ${chalk.red(error?.message || 'Unknown error')}`,
    );
    return null;
  }
}

export async function exchangeAuthorizationCodeForToken(
  cluster: string,
  authCode: string,
): Promise<{ accessToken: string; refreshToken: string } | null | undefined> {
  try {
    console.log(
      `${chalk.yellow('...')} Exchanging Access Token by Authorization Code...`,
    );
    // Step 2: Exchange token
    const tokenResponse = await axios.post(
      `https://${getSingleSignOnUrl(cluster)}/api/auth/exchange-token`,
      {
        code: authCode,
      },
      {
        headers: {
          'Content-Type': 'application/json',
        },
      },
    );

    console.log(`${chalk.green('✓')} Access Token received`);
    return tokenResponse.data as any;
  } catch (error: any) {
    console.error(
      `${chalk.red('✗')} Failed to exchange token: ${chalk.red(error?.message || 'Unknown error')}`,
    );
    return null;
  }
}
export async function getMyAccount(cluster: string, accessToken: string) {
  try {
    console.log(`${chalk.yellow('...')} Getting user information...`);
    const userResponse = await axios.get(
      `https://${getSingleSignOnUrl(cluster)}/api/account/me`,
      {
        headers: {
          Authorization: `Bearer ${accessToken}`,
          'X-Request-StackTrace': 'true',
        },
      },
    );
    console.log(`${chalk.green('✓')} User information received`);
    return userResponse.data;
  } catch (error: any) {
    console.error(
      `${chalk.red('✗')} Failed to get user information: ${chalk.red(error?.message || 'Unknown error')}`,
    );
    return null;
  }
}
export async function login(cluster: string) {
  const { username, password, clientId, clientSecret, redirectUri } =
    await inquirer.prompt([
      { type: 'input', name: 'username', message: 'Username:' },
      { type: 'password', name: 'password', message: 'Password:' },
      { type: 'input', name: 'clientId', message: 'Client ID:' },
      { type: 'password', name: 'clientSecret', message: 'Client Secret:' },
      { type: 'input', name: 'redirectUri', message: 'Redirect URI:' },
    ]);
  try {
    const authCode = await requestAuthorizationCode(
      cluster,
      username,
      password,
      clientId,
      redirectUri,
    );
    if (!authCode) return;
    const jwtToken = await exchangeAuthorizationCodeForToken(cluster, authCode);
    if (!jwtToken) return;
    var user = await getMyAccount(cluster, jwtToken.accessToken);
    useCluster(cluster, {
      user: {
        id: user.id,
        email: user.email,
        phoneNumber: user.phoneNumber,
        firstName: user.firstName,
        lastName: user.lastName,
        userName: user.userName,
        twoFactorEnabled: user.twoFactorEnabled,
        emailConfirmed: user.emailConfirmed,
        phoneNumberConfirmed: user.phoneNumberConfirmed,
      },
      jwt: jwtToken,
    });

    console.log(
      `${chalk.green('✓')} Logged in as ${chalk.green(user.userName)}`,
    );
  } catch (error: any) {
    console.error(
      `${chalk.red('✗')} Login failed: ${chalk.red(error?.message || 'Unknown error')}`,
    );
  }
}