import { input } from '@inquirer/prompts';
import { addLog, addLogs, ErrorLog, SuccessLog } from '@mintlify/previewing';
import { Box, Text } from 'ink';
import {
  calculatePKCECodeChallenge,
  randomNonce,
  randomPKCECodeVerifier,
  randomState,
} from 'openid-client';

import { isCI } from './agent.js';
import { startCallbackServer } from './callbackServer.js';
import { clearConfigValue, hasShownPublishPrompt, markPublishPromptShown } from './config.js';
import { API_URL, TOKEN_ENDPOINT } from './constants.js';
import { CMD_EXEC_PATH, isAI } from './helpers.js';
import { getEmailFromIdToken } from './idToken.js';
import { getAccessToken, storeCredentials } from './keyring.js';
import type { TokenResponse } from './login.js';

export interface SignupOptions {
  firstName?: string;
  lastName?: string;
  company?: string;
  email?: string;
}

const sendAIUsageMessage = () => {
  addLogs(
    <Text>Agent Detected - sending AI friendly prompt</Text>,
    <Text>{'<mint-cli-instructions>'}</Text>,
    <Text>
      You were asked to create a Mintlify account. Here is how to do that with the `mint signup`
      command. Fill in any values you already have from this conversation; ask the user directly for
      anything you don't — never invent a person's name, company, or email.
    </Text>,
    <Text>
      Command: `mint signup --firstName [firstName] --lastName [lastName] --company [company]
      --email [email]`.
    </Text>,
    <Text>
      Important: this command blocks until the user clicks a verification link sent to their email,
      which can take several minutes. Run it as a background task, not in the foreground — do not
      wait on it synchronously. You'll be notified when it finishes; then tell the user their
      account is ready.
    </Text>,
    <Text>{'</mint-cli-instructions>'}</Text>
  );
};

export const sendPublishPrompt = async () => {
  if (
    !isAI() ||
    isCI() ||
    process.env.MINTLIFY_SESSION_TOKEN ||
    (await getAccessToken().catch(() => undefined))
  ) {
    return;
  }
  if (hasShownPublishPrompt(CMD_EXEC_PATH)) {
    addLog(<Text>Not published yet. Run `mint signup` or `mint login` to publish.</Text>);
    return;
  }
  addLogs(
    <Text>{'<mint-cli-instructions>'}</Text>,
    <Text>Ready to publish? The Starter plan is free, no credit card needed.</Text>,
    <Text>
      Offer to create the user's Mintlify account with `mint signup --firstName [firstName]
      --lastName [lastName] --company [company] --email [email]`. Ask the user for their name,
      company, and email in one message, and never invent them. Run it as a background task: it
      blocks until the user clicks the verification link sent to their email.
    </Text>,
    <Text>Have an account: `mint login`.</Text>,
    <Text>After the email is verified, connect GitHub in the browser tab to deploy.</Text>,
    <Text>
      Your site will then be live at https://[subdomain].mintlify.site (`mint status` shows the
      exact URL).
    </Text>,
    <Text>{'</mint-cli-instructions>'}</Text>
  );
  await markPublishPromptShown(CMD_EXEC_PATH).catch(() => undefined);
};

export async function signup(options: SignupOptions = {}): Promise<void> {
  if (isAI() && (!options.firstName || !options.lastName || !options.company || !options.email)) {
    sendAIUsageMessage();
    return;
  }

  const firstName = options.firstName ?? (await input({ message: 'First name' }));
  const lastName = options.lastName ?? (await input({ message: 'Last name' }));
  const company = options.company ?? (await input({ message: 'Company name' }));
  const email = options.email ?? (await input({ message: 'Email' }));

  const codeVerifier = randomPKCECodeVerifier();
  const codeChallenge = await calculatePKCECodeChallenge(codeVerifier);
  const nonce = randomNonce();
  const clientState = randomState();
  const state = Buffer.from(JSON.stringify({ nonce, clientState })).toString('base64url');

  const { codePromise, close: closeServer } = await startCallbackServer();
  codePromise.catch(() => {});

  try {
    const res = await fetch(`${API_URL}/api/cli-onboarding/signup`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ firstName, lastName, company, email, state, codeChallenge }),
    });

    if (!res.ok) {
      const body = await res.json().catch(() => ({}));
      closeServer();
      addLog(<ErrorLog message={`signup failed: ${body.error ?? 'unknown error'}`} />);
      return;
    }
  } catch {
    closeServer();
    addLog(<ErrorLog message="signup failed: could not reach the server" />);
    return;
  }

  addLog(
    <Box flexDirection="column" gap={1} paddingY={1}>
      <Text bold>
        <Text color="green">◆ </Text>Check your email to verify your account
      </Text>
      <Box flexDirection="column" paddingLeft={3} gap={1}>
        <Text dimColor>We sent a verification link to {email}. Click it to continue.</Text>
      </Box>
    </Box>
  );

  let code: string;
  try {
    code = await codePromise;
  } catch {
    addLog(<ErrorLog message="signup cancelled" />);
    return;
  }

  const res = await fetch(TOKEN_ENDPOINT, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      grant_type: 'authorization_code',
      code,
      code_verifier: codeVerifier,
    }),
  });

  const body = await res.json().catch(() => ({}));

  if (!res.ok) {
    const reason = body.error_message ?? body.error ?? 'unknown error';
    addLog(<ErrorLog message={`signup failed: ${reason}`} />);
    return;
  }

  const token = body as TokenResponse;
  await storeCredentials(
    token.access_token,
    token.refresh_token,
    getEmailFromIdToken(token.id_token) ?? email
  );
  await clearConfigValue('subdomain').catch(() => undefined);
  addLog(<SuccessLog message="account created and logged in successfully" />);
  addLog(<Text>Continue in the browser tab where you verified your email to connect GitHub.</Text>);
}