import { spawn } from "node:child_process";
import {
  type CliTeam,
  type CliConfig,
  type CliUser,
  readConfig,
  updateConfig,
  writeConfig,
} from "./config.js";

const STACK_API_URL =
  process.env.FREESTYLE_STACK_API_URL ?? "https://api.stack-auth.com";
const STACK_PROJECT_ID =
  process.env.FREESTYLE_STACK_PROJECT_ID ??
  "0edf478c-f123-46fb-818f-34c0024a9f35";
const STACK_PUBLISHABLE_KEY =
  process.env.FREESTYLE_STACK_PUBLISHABLE_CLIENT_KEY ??
  "pck_h2aft7g9pqjzrkdnzs199h1may5wjtdtdxeex7m2wzp1r";
export const DEFAULT_DASHBOARD_URL = "https://dash.freestyle.sh";
const LOGIN_TIMEOUT_MS = 10 * 60 * 1000;
const POLL_INTERVAL_MS = 2_000;

interface TeamResponse {
  user: CliUser;
  defaultTeamId: string | null;
  teams: CliTeam[];
}

function clientHeaders(): Record<string, string> {
  return {
    "Content-Type": "application/json",
    "x-stack-project-id": STACK_PROJECT_ID,
    "x-stack-publishable-client-key": STACK_PUBLISHABLE_KEY,
    "x-stack-access-type": "client",
  };
}

export function openBrowser(url: string): void {
  const [command, ...args] =
    process.platform === "darwin"
      ? ["open", url]
      : process.platform === "win32"
        ? ["cmd", "/c", "start", "", url.replace(/&/g, "^&")]
        : ["xdg-open", url];
  const child = spawn(command, args, { stdio: "ignore", detached: true });
  child.on("error", () => {});
  child.unref();
}

export async function browserLogin(options: {
  dashboardUrl?: string;
  open?: boolean;
} = {}): Promise<string> {
  const dashboardUrl = (
    options.dashboardUrl ??
    process.env.FREESTYLE_DASHBOARD ??
    DEFAULT_DASHBOARD_URL
  ).replace(/\/+$/, "");
  const started = await fetch(`${STACK_API_URL}/api/v1/auth/cli`, {
    method: "POST",
    headers: clientHeaders(),
    body: JSON.stringify({ expires_in_millis: LOGIN_TIMEOUT_MS }),
  });
  if (!started.ok) {
    throw new Error(`Could not start Stack CLI login (${started.status}): ${await started.text()}`);
  }
  const codes = (await started.json()) as {
    polling_code?: string;
    login_code?: string;
  };
  if (!codes.polling_code || !codes.login_code) {
    throw new Error("Stack CLI login did not return polling and login codes");
  }

  const loginUrl = `${dashboardUrl}/handler/cli-auth-confirm?login_code=${encodeURIComponent(codes.login_code)}`;
  console.error(`Open this URL to authenticate:\n${loginUrl}\n`);
  if (options.open !== false) openBrowser(loginUrl);

  const deadline = Date.now() + LOGIN_TIMEOUT_MS;
  while (Date.now() < deadline) {
    const response = await fetch(`${STACK_API_URL}/api/v1/auth/cli/poll`, {
      method: "POST",
      headers: clientHeaders(),
      body: JSON.stringify({ polling_code: codes.polling_code }),
    });
    if (!response.ok) {
      throw new Error(`Stack CLI login polling failed (${response.status})`);
    }
    const result = (await response.json()) as {
      status?: string;
      refresh_token?: string;
      error?: string;
    };
    if (result.status === "completed" || result.status === "success") {
      if (!result.refresh_token) throw new Error("Login completed without a refresh token");
      updateConfig({ refreshToken: result.refresh_token, dashboardUrl });
      return result.refresh_token;
    }
    if (result.status && !["pending", "waiting"].includes(result.status)) {
      throw new Error(result.error ?? `Authentication ${result.status}`);
    }
    await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
  }
  throw new Error("Timed out waiting for browser authentication");
}

export async function refreshAccessToken(config = readConfig()): Promise<string> {
  const refreshToken =
    process.env.FREESTYLE_STACK_REFRESH_TOKEN ?? config.refreshToken;
  if (!refreshToken) {
    throw new Error("Not logged in. Run `freestyle login` or provide FREESTYLE_API_KEY.");
  }
  const response = await fetch(
    `${STACK_API_URL}/api/v1/auth/sessions/current/refresh`,
    {
      method: "POST",
      headers: { ...clientHeaders(), "x-stack-refresh-token": refreshToken },
      body: "{}",
    },
  );
  if (!response.ok) {
    throw new Error("Your Freestyle login expired. Run `freestyle login` again.");
  }
  const result = (await response.json()) as {
    access_token?: string;
    refresh_token?: string;
  };
  if (!result.access_token) throw new Error("Stack did not return an access token");
  if (result.refresh_token && result.refresh_token !== config.refreshToken) {
    updateConfig({ refreshToken: result.refresh_token });
  }
  return result.access_token;
}

export function dashboardUrl(config = readConfig()): string {
  return (
    process.env.FREESTYLE_DASHBOARD ??
    config.dashboardUrl ??
    DEFAULT_DASHBOARD_URL
  ).replace(/\/+$/, "");
}

export async function refreshTeams(
  accessToken: string,
  config = readConfig(),
): Promise<CliConfig> {
  const response = await fetch(`${dashboardUrl(config)}/api/cli/teams`, {
    headers: { Authorization: `Bearer ${accessToken}` },
  });
  if (!response.ok) {
    throw new Error(`Could not load Freestyle teams (${response.status}): ${await response.text()}`);
  }
  const result = (await response.json()) as TeamResponse;
  const activeStillExists = result.teams.some(
    (team) => team.teamId === config.activeTeamId,
  );
  const activeTeamId = activeStillExists
    ? config.activeTeamId
    : result.defaultTeamId ?? result.teams[0]?.teamId;
  const updated: CliConfig = {
    ...config,
    version: 2,
    user: result.user,
    teams: result.teams,
    defaultTeamId: result.defaultTeamId ?? undefined,
    activeTeamId,
  };
  writeConfig(updated);
  return updated;
}
