import { parse } from "jsr:@std/yaml@1";
import { isAbsolute, relative, resolve } from "jsr:@std/path@1";

export type BotProfile = {
  type: "claude" | "codex";
  model: string;
  token?: string;
  tokenEnv?: string;
};

const DEFAULT_MODELS: Record<BotProfile["type"], string> = {
  claude: "claude-sonnet-5",
  codex: "gpt-5.6-terra",
};

export type ProfileFileSystem = {
  realPath(path: string): Promise<string>;
  stat(path: string): Promise<{ isFile: boolean }>;
  readTextFile(path: string): Promise<string>;
};

const systemFileSystem: ProfileFileSystem = {
  realPath: Deno.realPath,
  async stat(path) {
    return { isFile: (await Deno.stat(path)).isFile };
  },
  readTextFile: Deno.readTextFile,
};

export async function readProfilesFile(
  file: string,
  workspace: string,
  fileSystem: ProfileFileSystem = systemFileSystem,
): Promise<string> {
  if (isAbsolute(file)) {
    throw new Error("profiles-file must be repository-relative");
  }
  const root = await fileSystem.realPath(workspace);
  const target = await fileSystem.realPath(resolve(root, file));
  const pathFromRoot = relative(root, target);
  if (
    pathFromRoot === "" || pathFromRoot === ".." ||
    pathFromRoot.startsWith("../") || pathFromRoot.startsWith("..\\") ||
    isAbsolute(pathFromRoot)
  ) {
    throw new Error("profiles-file must stay inside the repository");
  }
  if (!(await fileSystem.stat(target)).isFile) {
    throw new Error("profiles-file must name a file");
  }
  return await fileSystem.readTextFile(target);
}

export function parseProfiles(
  text: string,
  environment: Record<string, string>,
): BotProfile[] {
  const value: unknown = parse(text);
  if (!Array.isArray(value) || value.length === 0) {
    throw new Error("profiles must contain at least one profile");
  }
  return value.map((entry: unknown, index) => {
    const at = `profiles[${index}]`;
    if (typeof entry !== "object" || entry === null) {
      throw new Error(`${at}: expected a mapping`);
    }
    const allowed = new Set(["type", "model", "token-env"]);
    for (const key of Object.keys(entry)) {
      if (!allowed.has(key)) throw new Error(`${at}.${key}: unknown field`);
    }
    const { type, model, "token-env": tokenEnv } = entry as Record<
      string,
      unknown
    >;
    if (type !== "claude" && type !== "codex") {
      throw new Error(`${at}.type: expected "claude" or "codex"`);
    }
    if (model !== undefined && (typeof model !== "string" || model === "")) {
      throw new Error(`${at}.model: expected a model name`);
    }
    if (
      tokenEnv !== undefined &&
      (typeof tokenEnv !== "string" ||
        !/^BOT_PROFILE_[A-Z0-9_]+$/.test(tokenEnv))
    ) {
      throw new Error(`${at}.token-env: must start with BOT_PROFILE_`);
    }
    if (type === "claude" && tokenEnv === undefined) {
      throw new Error(`${at}.token-env: required for Claude`);
    }
    const token = tokenEnv === undefined ? undefined : environment[tokenEnv];
    if (tokenEnv !== undefined && !token) {
      throw new Error(`${at}.token-env: ${tokenEnv} is not set`);
    }
    return {
      type,
      model: model ?? DEFAULT_MODELS[type],
      ...(token && { token }),
      ...(tokenEnv && { tokenEnv }),
    };
  });
}

function isUsageExhausted(error: unknown): boolean {
  return /(?:usage|rate) limit|hit your limit|insufficient_quota|exceeded your current quota|too many requests|(?:api error|http error|http|status(?: code)?)[ :]+4(?:02|29)\b/i
    .test(String(error));
}

export async function runProfiles<T>(
  profiles: BotProfile[],
  attempt: (profile: BotProfile) => Promise<T>,
): Promise<T> {
  for (const [index, profile] of profiles.entries()) {
    try {
      return await attempt(profile);
    } catch (error) {
      if (!isUsageExhausted(error) || index === profiles.length - 1) {
        throw error;
      }
      console.error(`${profile.type} usage exhausted; trying next profile`);
    }
  }
  throw new Error("profiles must contain at least one profile");
}

export function sanitizedEnvironment(
  environment: Record<string, string>,
  profiles: BotProfile[],
): Record<string, string> {
  const result = { ...environment };
  for (
    const name of [
      "PROFILES",
      "REVIEWER_TOKEN",
      "BOT_TOKEN",
      "CLAUDE_CODE_OAUTH_TOKEN",
      "ANTHROPIC_API_KEY",
      "ANTHROPIC_AUTH_TOKEN",
      "OPENAI_API_KEY",
      "CODEX_API_KEY",
      "CODEX_ACCESS_TOKEN",
    ]
  ) {
    delete result[name];
  }
  for (const name of Object.keys(result)) {
    if (name.startsWith("BOT_PROFILE_")) delete result[name];
  }
  for (const profile of profiles) {
    if (profile.tokenEnv) delete result[profile.tokenEnv];
  }
  return result;
}

export function agentEnvironment(
  environment: Record<string, string>,
  profile: BotProfile,
  profiles: BotProfile[],
): Record<string, string> {
  const result = sanitizedEnvironment(environment, profiles);
  if (profile.token) {
    result[
      profile.type === "claude" ? "CLAUDE_CODE_OAUTH_TOKEN" : "OPENAI_API_KEY"
    ] = profile.token;
  }
  return result;
}