import { Command } from "commander";
import { readFileSync, existsSync } from "node:fs";
import { join } from "node:path";
import chalk from "chalk";
import ora from "ora";
import { apiRequest } from "../lib/api-client.js";
import type { SkillSummary } from "@skills-hub-ai/shared";

/**
 * Read dependency names from common project files in the current directory.
 */
function detectDeps(cwd: string): string[] {
  const deps: string[] = [];

  // package.json (Node.js)
  const pkgPath = join(cwd, "package.json");
  if (existsSync(pkgPath)) {
    try {
      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
      if (pkg.dependencies) deps.push(...Object.keys(pkg.dependencies));
      if (pkg.devDependencies) deps.push(...Object.keys(pkg.devDependencies));
    } catch {
      /* skip malformed */
    }
  }

  // requirements.txt (Python)
  const reqPath = join(cwd, "requirements.txt");
  if (existsSync(reqPath)) {
    try {
      const lines = readFileSync(reqPath, "utf-8").split("\n");
      for (const line of lines) {
        const name = line
          .trim()
          .split(/[>=<!\[;#]/)[0]
          .trim();
        if (name) deps.push(name);
      }
    } catch {
      /* skip */
    }
  }

  // Gemfile (Ruby)
  const gemPath = join(cwd, "Gemfile");
  if (existsSync(gemPath)) {
    try {
      const lines = readFileSync(gemPath, "utf-8").split("\n");
      for (const line of lines) {
        const match = line.match(/^\s*gem\s+['"]([^'"]+)['"]/);
        if (match) deps.push(match[1]);
      }
    } catch {
      /* skip */
    }
  }

  // go.mod (Go)
  const goModPath = join(cwd, "go.mod");
  if (existsSync(goModPath)) {
    try {
      const content = readFileSync(goModPath, "utf-8");
      const requireBlock = content.match(/require\s*\(([\s\S]*?)\)/);
      if (requireBlock) {
        const lines = requireBlock[1].split("\n");
        for (const line of lines) {
          const parts = line.trim().split(/\s+/);
          if (parts[0] && !parts[0].startsWith("//")) {
            // Extract last segment of Go module path
            const segments = parts[0].split("/");
            deps.push(segments[segments.length - 1]);
          }
        }
      }
    } catch {
      /* skip */
    }
  }

  // Cargo.toml (Rust)
  const cargoPath = join(cwd, "Cargo.toml");
  if (existsSync(cargoPath)) {
    try {
      const content = readFileSync(cargoPath, "utf-8");
      const depBlock = content.match(/\[dependencies\]([\s\S]*?)(?:\n\[|$)/);
      if (depBlock) {
        const lines = depBlock[1].split("\n");
        for (const line of lines) {
          const match = line.match(/^\s*([a-zA-Z0-9_-]+)\s*=/);
          if (match) deps.push(match[1]);
        }
      }
    } catch {
      /* skip */
    }
  }

  // pubspec.yaml (Dart/Flutter)
  const pubspecPath = join(cwd, "pubspec.yaml");
  if (existsSync(pubspecPath)) {
    try {
      const content = readFileSync(pubspecPath, "utf-8");
      const depBlock = content.match(/^dependencies:\s*\n((?:[ \t]+.*\n)*)/m);
      if (depBlock) {
        const lines = depBlock[1].split("\n");
        for (const line of lines) {
          const match = line.match(/^\s+([a-zA-Z0-9_]+)\s*:/);
          if (match) deps.push(match[1]);
        }
      }
    } catch {
      /* skip */
    }
  }

  return [...new Set(deps)];
}

export { detectDeps as _detectDeps };

type SuggestResponse =
  SkillSummary[] | { data?: SkillSummary[] | null } | null | undefined;

/**
 * Read the skill list out of a suggest-by-deps response.
 *
 * The endpoint returned a bare array until 2026-07-30 and a
 * {data,cursor,hasMore} envelope after. Both shapes are accepted on purpose:
 * every CLI already on npm ships the old unwrapping, so a build that
 * understood only the envelope would break against an older self-hosted API,
 * and one that understood only the array crashes with "skills is not
 * iterable" against the current one. Anything unexpected degrades to an empty
 * list, because a suggestion feature is not worth a stack trace.
 */
export function unwrapSkillList(response: SuggestResponse): SkillSummary[] {
  if (Array.isArray(response)) return response;
  const data = response?.data;
  return Array.isArray(data) ? data : [];
}

export const suggestCommand = new Command("suggest")
  .description("Suggest skills based on your project dependencies")
  .option("-l, --limit <n>", "Number of suggestions", "10")
  .action(async (options) => {
    const spinner = ora("Scanning project dependencies...").start();

    try {
      const deps = detectDeps(process.cwd());

      if (deps.length === 0) {
        spinner.warn(
          "No dependency files found (package.json, requirements.txt, Gemfile, go.mod, Cargo.toml, pubspec.yaml)",
        );
        return;
      }

      // Limit to top 50 deps to avoid URL/payload size issues
      const cappedDeps = deps.slice(0, 50);
      spinner.text = `Found ${deps.length} dependencies${deps.length > 50 ? ` (sending top 50)` : ""}. Finding matching skills...`;

      // POST /search/suggest-by-deps returned a bare array until 2026-07-30 and
      // a {data,cursor,hasMore} envelope after. Accept BOTH shapes rather than
      // just the new one: every CLI already published to npm ships the old
      // unwrapping, so a version that only understands the envelope would break
      // the moment it met an older self-hosted API, and one that only
      // understands the array crashes with "skills is not iterable" against
      // the current one.
      const response = await apiRequest<SuggestResponse>(
        "/api/v1/search/suggest-by-deps",
        {
          method: "POST",
          body: JSON.stringify({
            deps: cappedDeps,
            limit: parseInt(options.limit, 10),
          }),
        },
      );
      const skills = unwrapSkillList(response);

      if (skills.length === 0) {
        spinner.info("No matching skills found for your project dependencies.");
        return;
      }

      spinner.succeed(`Found ${skills.length} skills for your stack:\n`);

      for (const skill of skills) {
        const score =
          skill.qualityScore !== null
            ? chalk.green(`[${skill.qualityScore}]`)
            : chalk.gray("[--]");

        console.log(
          `  ${score} ${chalk.bold(skill.name)} ${chalk.gray(`v${skill.latestVersion}`)}`,
        );
        console.log(`     ${chalk.gray(skill.description.slice(0, 80))}`);
        console.log(
          `     ${chalk.cyan(`npx @skills-hub-ai/cli install ${skill.slug}`)}  ${chalk.gray(`${skill.installCount} installs`)}`,
        );
        console.log();
      }
    } catch (err) {
      spinner.fail(
        chalk.red(err instanceof Error ? err.message : "Suggestion failed"),
      );
      process.exit(1);
    }
  });