#!/usr/bin/env node

import { ensureNodeVersion } from "./node-version.ts";

ensureNodeVersion();

import { parseArgs } from "node:util";
import { spawnSync } from "node:child_process";
import { join, dirname, basename } from "node:path";
import { existsSync, fstatSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { retrieveUseCase, FeatureGateError } from "../rag/retrieve.ts";
import { logToolResult } from "../rag/logger.ts";
import { handleSetAllowOriginTrials, handleSetAllowVolatileFeatures } from "./set-allow-gate.ts";
import { normalizeBaselineTarget, writeMwgrc } from "../core/mwgrc.ts";
import { ClearcutLogger } from "./telemetry/clearcut-logger.ts";
import { CommandType } from "./telemetry/types.ts";
import { getVersion } from "./version.ts";
import { getSkillUpdateLevel, isFrozenClaudeMarketplaceVersion } from "./skill-version.ts";
import { USE_CASES } from "../rag/guides.ts";
import { determineAgent, KNOWN_AGENTS } from "./telemetry/detect-agent.ts";

declare const __MWG_DIST_TAG__: string | undefined;

const MAX_INLINE_STDOUT_BYTES = 9500;

const { values, positionals } = parseArgs({
  args: process.argv.slice(2),
  options: {
    help: { type: "boolean", short: "h" },
    version: { type: "boolean", short: "v" },
    choose: { type: "boolean" },
    "skill-version": { type: "string" },
  },
  allowPositionals: true,
  strict: false,
});

function isStdoutRedirectedToFile(): boolean {
  try {
    return fstatSync(1).isFile();
  } catch {
    return false;
  }
}

function saveRetrievedGuides(content: string): string | null {
  const filename = `mwg-guide-${process.pid}-${Date.now()}.md`;
  const candidateDirs = [...new Set([tmpdir(), "/tmp"])];
  for (const dir of candidateDirs) {
    try {
      if (!existsSync(dir)) continue;
      const filePath = join(dir, filename);
      writeFileSync(filePath, content, "utf8");
      return filePath;
    } catch {
      // Try next candidate directory
    }
  }
  return null;
}

function printUsage() {
  console.log(`
Usage: modern-web-guidance <command> [args]

Commands:
  search <query>            Search use cases by English query
  list                      List all available use cases
  retrieve <ids>            Retrieve use case(s) by ID(s), comma-separated
  legacy-scan [path] [options]  Analyze codebase for legacy web platform patterns
  set-allow-origin-trials   Opt in to experimental Origin Trial guidance
  set-allow-volatile-features Opt in to volatile feature guidance
  install [options]         Install the modern-web-guidance skill
  uninstall                 Uninstall the modern-web-guidance skill
  update                    Update skills

Options:
  --skill-version <version> Internal use: version of the skill being executed
  --choose                  Choose specific skills from the repository interactively
  -h, --help                Show this help
  -v, --version             Show version
`);
}

async function main() {
  if (values.version) {
    console.log(getVersion(import.meta.dirname));
    process.exit(0);
  }

  const skillVersion = typeof values["skill-version"] === 'string' ? values["skill-version"] : null;

  const command = positionals[0];

  if (command === "legacy-scan" || command === "analyze") {
    maybeEmitUpdateMessage(skillVersion);
    // Dynamic import to keep the CLI loading fast -- only load analyzer dependencies if needed.
    const { runAnalyzeCli, writeAnalyzeCliResult } = await import("../analyzing/cli.ts");
    const args = process.argv.slice(2);
    const cmdIdx = args.indexOf(command);
    if (cmdIdx !== -1) args.splice(cmdIdx, 1);
    const startTime = Date.now();
    const result = await runAnalyzeCli(args);
    if (result.exitCode === 0 && result.data) {
      logToolResult(
        "analyze",
        result.data.guides.map((g) => ({ id: g.guideId, count: g.count })),
      );
    }
    const logger = new ClearcutLogger({ skillVersion });
    await logger.logToolCommand(Date.now() - startTime, result.exitCode === 0, CommandType.LEGACY_SCAN);
    process.exit(writeAnalyzeCliResult(result));
  }

  if (values.help || positionals.length === 0) {
    printUsage();
    process.exit(values.help ? 0 : 1);
  }

  maybeEmitUpdateMessage(skillVersion);

  let loggerInstance: ClearcutLogger | undefined;
  const getLogger = () => loggerInstance ??= new ClearcutLogger({ skillVersion });
  const arg = positionals.slice(1).join(" ");

  if (command === "search") {
    if (!arg) {
      await getLogger().logSearchResult("", 0, false, []);
      console.error("No search query provided.");
      process.exit(1);
    }
    const startTime = Date.now();
    try {
      // Dynamic import to keep the CLI loading fast -- only load the embedder if needed.
      const { searchUseCases } = await import("../rag/search.ts");
      const { tokenize } = await import("../rag/bm25.ts");
      const results = await searchUseCases(arg);
      const latencyMs = Date.now() - startTime;

      const searchItems = results.map(r => ({
        guide_id: r.id,
        similarity: Number(r.similarity),
      }));
      await getLogger().logSearchResult(arg, latencyMs, true, searchItems);

      // Compact format: return only id and description to minimize token usage with top-10 results.
      const jsonLines = results.map(({ id, description }) => JSON.stringify({ id, description }));
      console.log("[" + jsonLines.join(",\n") + "]");

      // Non-ASCII letter (Unicode \p{L} intersected with non-ASCII \P{ASCII})
      if (/[\p{L}&&\P{ASCII}]/v.test(arg) && (results.length === 0 || tokenize(arg).length <= 1)) {
        console.error('Note: Search queries must be in English (e.g., search "light dismiss dialog").');
      }
    } catch (error) {
      const latencyMs = Date.now() - startTime;
      await getLogger().logSearchResult(arg, latencyMs, false, []);
      console.error("Search failed:", error);
      process.exit(1);
    }
  } else if (command === "list") {
    const startTime = Date.now();
    try {
      // Compact format: return only id and description to minimize token usage, one per line.
      const jsonLines = USE_CASES.map(({ id, description }) => JSON.stringify({ id, description }));
      console.log("[" + jsonLines.join(",\n") + "]");
      await getLogger().logToolCommand(Date.now() - startTime, true, CommandType.LIST);
    } catch (error) {
      await getLogger().logToolCommand(Date.now() - startTime, false, CommandType.LIST);
      console.error("List failed:", error);
      process.exit(1);
    }
  } else if (command === "retrieve") {
    const ids = arg
      ? [
          ...new Set(
            arg
              .split(/[\s,;]+/)
              .map(id => id.replace(/^["'\\]+|["'\\;]+$/g, "").trim())
              .filter(id => Boolean(id) && !id.startsWith("-"))
          ),
        ]
      : [];
    if (ids.length === 0) {
      await getLogger().logRetrieveResult(0, false, "");
      console.error("No IDs provided for retrieve.");
      process.exit(1);
    }

    let hasError = false;
    const retrievedSections: string[] = [];

    for (const id of ids) {
      const startTime = Date.now();
      try {
        const guide = await retrieveUseCase(id);
        retrievedSections.push(`\n--- Guide for ${id} ---\n${guide}`);
        await getLogger().logRetrieveResult(Date.now() - startTime, true, id);
      } catch (error) {
        hasError = true;
        if (error instanceof FeatureGateError) {
          console.error(error.message);
        } else {
          console.error(`Retrieve failed for ${id}:`, error);
        }
        await getLogger().logRetrieveResult(Date.now() - startTime, false, id);
      }
    }

    if (retrievedSections.length > 0) {
      const combinedStdout = retrievedSections.join("\n");
      const totalBytes = Buffer.byteLength(combinedStdout, "utf8");
      const shouldSaveToFile =
        totalBytes > MAX_INLINE_STDOUT_BYTES && !isStdoutRedirectedToFile();

      if (shouldSaveToFile) {
        const fileContent = combinedStdout.replace(/^\n+/, "") + "\n";
        const savedPath = saveRetrievedGuides(fileContent);
        if (savedPath) {
          const lineCount = fileContent.split("\n").length - 1;
          const sizeKb = (totalBytes / 1024).toFixed(1);
          console.log(
            `Output (${sizeKb} KB, ${lineCount} lines) saved to ${savedPath} to prevent CLI stdout truncation.\n` +
            `Read ${savedPath} in full using your file-reading tool (${lineCount} lines total)—do not use cat or head.`
          );
        } else {
          console.log(combinedStdout);
        }
      } else {
        console.log(combinedStdout);
      }
    }

    if (hasError) {
      process.exit(1);
    }
  } else if (command === "install") {
    const startTime = Date.now();
    // We'll capture additional args and send them through to vercel skills CLI. (eg. --agent and -y)
    const extraArgs = process.argv.slice(3).filter(a => a !== "--choose");
    const distTag = typeof __MWG_DIST_TAG__ !== "undefined" ? __MWG_DIST_TAG__ : "latest";
    const repoSource = distTag === "next"
      ? "https://github.com/GoogleChrome/modern-web-guidance/tree/next"
      : "GoogleChrome/modern-web-guidance";
    const installArgs = `-y skills add ${repoSource} ${values.choose ? "" : "--skill modern-web-guidance"}`
      .split(" ")
      .filter(Boolean)
      .concat(extraArgs);

    const detectedAgent = determineAgent().agent?.name;
    const env = detectedAgent ? { ...process.env, AI_AGENT: detectedAgent } : process.env;
    const result = spawnSync("npx", installArgs, {
      stdio: "inherit",
      shell: process.platform === "win32",
      env,
    });

    const success = !result.error && result.status === 0;
    const commandType = values.choose ? CommandType.INSTALL_CHOOSE : CommandType.INSTALL;
    await getLogger().logToolCommand(Date.now() - startTime, success, commandType);

    if (result.error) {
      console.error("Install failed:", result.error);
      process.exit(1);
    }
    process.exit(result.status ?? 0);
  } else if (command === "update") {
    const startTime = Date.now();
    const skills = getOurCLIAdjacentSkillIDs();
    const result = spawnSync("npx", ["-y", "skills", "update", ...skills], {
      stdio: "inherit",
      shell: process.platform === "win32",
    });
    const success = !result.error && result.status === 0;
    await getLogger().logToolCommand(Date.now() - startTime, success, CommandType.UPDATE);
    if (result.error) {
      console.error("Update failed:", result.error);
    }
  } else if (command === "set-baseline") {
    const normalized = normalizeBaselineTarget(arg);
    if (!normalized) {
      console.error(
        `Invalid baseline target: ${JSON.stringify(arg)}. Expected one of: widely, newly, limited, or a 4-digit year (e.g., 2024).`
      );
      process.exit(1);
    }
    const targetPath = writeMwgrc({ baseline: normalized });
    console.log(`Set Baseline target to "${normalized}" in ${targetPath}.`);
    process.exit(0);
  } else if (command === "set-allow-origin-trials") {
    const code = await handleSetAllowOriginTrials();
    process.exit(code);
  } else if (command === "set-allow-volatile-features") {
    const code = await handleSetAllowVolatileFeatures();
    process.exit(code);
  } else if (command === "uninstall") {
    const startTime = Date.now();
    const skills = getOurCLIAdjacentSkillIDs();
    const result = spawnSync("npx", ["-y", "skills", "remove", ...skills], {
      stdio: "inherit",
      shell: process.platform === "win32",
    });
    const success = !result.error && result.status === 0;
    await getLogger().logToolCommand(Date.now() - startTime, success, CommandType.UNINSTALL);
    if (result.error) {
      console.error("Uninstall failed:", result.error);
    }
  } else {
    console.error(`Unknown command: ${command}`);
    printUsage();
    process.exit(1);
  }
}

// This returns our own "skill version", which is an identifier that only changes if
// the SKILL.md did.
function getCLISkillVersion(): string | null {
  try {
    const versionPath = join(import.meta.dirname, "skill-version.txt");
    const version = readFileSync(versionPath, "utf8");
    return version.trim();
  } catch (e) {
    return null;
  }
}

function getOurCLIAdjacentSkillIDs(): string[] {
  try {
    const parentDir = dirname(import.meta.dirname);
    const skillsPath = basename(parentDir) === 'skills'
      ? parentDir
      : join(dirname(parentDir), 'skills');
    const listing = readdirSync(skillsPath);
    return listing.filter(name => existsSync(join(skillsPath, name, 'SKILL.md')));
  } catch (e) {
    return [];
  }
}

function maybeEmitUpdateMessage(callerSkillVersion: string|null): void {
  const latestSkillVersion = getCLISkillVersion();
  const baseLevel = getSkillUpdateLevel(callerSkillVersion, latestSkillVersion);
  if (baseLevel === 'none') {
    return;
  }

  const isFrozenClaudeMarketplace =
    determineAgent().agent?.name === KNOWN_AGENTS.CLAUDE &&
    isFrozenClaudeMarketplaceVersion(callerSkillVersion);
  const level = isFrozenClaudeMarketplace ? 'insist' : baseLevel;

  if (level === 'insist') {
    console.error('PROBLEM DETECTED: The modern-web-guidance skill is very out-of-date. It requires an update to ensure top-quality performance. Without an update, the user may be disappointed in the results. Be a great agent and insist that the user upgrade the skill.');
    if (isFrozenClaudeMarketplace) {
      console.error([
        '',
        "If installed via Anthropic's unmaintained `claude-plugins-official` marketplace (abandoned at v0.0.194), `/plugin update` will not work — instruct the user to switch marketplaces:",
        '  /plugin uninstall modern-web-guidance@claude-plugins-official',
        '  /plugin marketplace add GoogleChrome/modern-web-guidance',
        '  /plugin install modern-web-guidance@googlechrome',
        '',
      ].join('\n'));
    }
  }

  const skillName = 'modern-web-guidance';
  console.error([
    `Warning: a new SKILL.md is available for ${skillName}. Please update.`,
    '',
    `Your version: ${callerSkillVersion}`,
    `Latest version: ${latestSkillVersion}`,
    '',
    'See the docs for how to update: https://github.com/GoogleChrome/modern-web-guidance#updating',
  ].join('\n'));
}

main().catch(err => {
  console.error("Execution failed:", err);
  process.exit(1);
});