import { tool } from "@opencode-ai/plugin";
import * as os from "node:os";
import * as path from "node:path";
import * as fs from "node:fs";

type WindowLaunchPlan = {
  model: string;
  windowName: string;
};

type CommandResult = {
  ok: boolean;
  stdout: string;
  stderr: string;
};

const MAX_SUGGESTIONS = 3;
const WINDOW_NAME_LIMIT = 24;

/**
 * Runs a command and captures its output without throwing on non-zero exit codes.
 *
 * @param parts Command segments to pass to the shell.
 * @returns The exit status plus captured stdout and stderr.
 *
 * @example
 * ```ts
 * const result = await runCommand(["command", "-v", "tmux"]);
 * if (!result.ok) {
 *   return "Error: `tmux` is not installed.";
 * }
 * ```
 */
async function runCommand(parts: string[]): Promise<CommandResult> {
  const result = await Bun.$`${parts}`.quiet().nothrow();

  return {
    ok: result.exitCode === 0,
    stdout: result.stdout.toString().trim(),
    stderr: result.stderr.toString().trim(),
  };
}

/**
 * Escapes a value for safe use inside a shell command string.
 *
 * @param value Raw user-provided value.
 * @returns A POSIX-safe single-quoted string.
 *
 * @example
 * ```ts
 * const command = `opencode --model ${shellQuote("openai/gpt-5.4")}`;
 * ```
 */
function shellQuote(value: string): string {
  return `'${value.replace(/'/g, `'"'"'`)}'`;
}

/**
 * Normalizes requested model ids by trimming whitespace and dropping empty items.
 *
 * @param models Raw tool input.
 * @returns Clean model ids in the original order.
 *
 * @example
 * ```ts
 * const normalized = normalizeModels([" openai/gpt-5.4 ", ""]);
 * // ["openai/gpt-5.4"]
 * ```
 */
function normalizeModels(models: string[] | undefined): string[] {
  return (models ?? []).map((model) => model.trim()).filter(Boolean);
}

/**
 * Finds duplicate values while preserving their first repeated occurrence order.
 *
 * @param values Values to inspect.
 * @returns Duplicate entries exactly once each.
 *
 * @example
 * ```ts
 * const duplicates = findDuplicates(["a", "b", "a", "b"]);
 * // ["a", "b"]
 * ```
 */
function findDuplicates(values: string[]): string[] {
  const seen = new Set<string>();
  const duplicates = new Set<string>();

  for (const value of values) {
    if (seen.has(value)) {
      duplicates.add(value);
      continue;
    }

    seen.add(value);
  }

  return [...duplicates];
}

/**
 * Builds a short tmux-safe window label from a model id.
 *
 * @param model Full model id.
 * @returns A concise window label.
 *
 * @example
 * ```ts
 * const label = createWindowBaseName("openai/gpt-5.4");
 * // "gpt-5-4"
 * ```
 */
function createWindowBaseName(model: string): string {
  const preferredPart = model.split("/").at(-1) ?? model;
  const sanitized = preferredPart
    .toLowerCase()
    .replace(/[^a-z0-9]+/g, "-")
    .replace(/^-+|-+$/g, "")
    .slice(0, WINDOW_NAME_LIMIT);

  return sanitized || "model";
}

/**
 * Makes window names unique when sanitized model labels collide.
 *
 * @param models Validated model ids.
 * @returns Window plans containing the full model id and unique tmux window name.
 *
 * @example
 * ```ts
 * const plans = createWindowPlans(["provider/a", "other/a"]);
 * // [{ model: "provider/a", windowName: "a" }, { model: "other/a", windowName: "a-2" }]
 * ```
 */
function createWindowPlans(models: string[]): WindowLaunchPlan[] {
  const counts = new Map<string, number>();

  return models.map((model) => {
    const baseName = createWindowBaseName(model);
    const nextCount = (counts.get(baseName) ?? 0) + 1;
    counts.set(baseName, nextCount);

    if (nextCount === 1) {
      return { model, windowName: baseName };
    }

    const suffix = `-${nextCount}`;
    const trimmedBase = baseName.slice(0, Math.max(1, WINDOW_NAME_LIMIT - suffix.length));

    return {
      model,
      windowName: `${trimmedBase}${suffix}`,
    };
  });
}

/**
 * Computes Levenshtein distance for fuzzy model suggestions.
 *
 * @param left First string.
 * @param right Second string.
 * @returns Edit distance between the two strings.
 *
 * @example
 * ```ts
 * const distance = levenshtein("gpt5.4", "gpt-5.4");
 * // 1
 * ```
 */
function levenshtein(left: string, right: string): number {
  const row = Array.from({ length: right.length + 1 }, (_, index) => index);

  for (let leftIndex = 1; leftIndex <= left.length; leftIndex += 1) {
    let previous = row[0];
    row[0] = leftIndex;

    for (let rightIndex = 1; rightIndex <= right.length; rightIndex += 1) {
      const current = row[rightIndex];
      const cost = left[leftIndex - 1] === right[rightIndex - 1] ? 0 : 1;

      row[rightIndex] = Math.min(
        row[rightIndex] + 1,
        row[rightIndex - 1] + 1,
        previous + cost,
      );
      previous = current;
    }
  }

  return row[right.length];
}

/**
 * Suggests close model ids for invalid input.
 *
 * @param requested Invalid requested model id.
 * @param allowlist Known valid model ids.
 * @returns Up to three likely matches ordered by relevance.
 *
 * @example
 * ```ts
 * const suggestions = suggestModels("openai/gpt5.4", ["openai/gpt-5.4", "openai/gpt-5.4-pro"]);
 * // ["openai/gpt-5.4", "openai/gpt-5.4-pro"]
 * ```
 */
function suggestModels(requested: string, allowlist: string[]): string[] {
  const normalizedRequested = requested.toLowerCase();

  return allowlist
    .map((candidate) => {
      const normalizedCandidate = candidate.toLowerCase();
      const distance = levenshtein(normalizedRequested, normalizedCandidate);
      const containsBoost =
        normalizedCandidate.includes(normalizedRequested) ||
        normalizedRequested.includes(normalizedCandidate)
          ? -2
          : 0;

      return {
        candidate,
        score: distance + containsBoost,
      };
    })
    .sort((left, right) => left.score - right.score || left.candidate.localeCompare(right.candidate))
    .slice(0, MAX_SUGGESTIONS)
    .map(({ candidate }) => candidate);
}

/**
 * Formats invalid model errors with repair hints.
 *
 * @param invalidModels Invalid requested model ids.
 * @param allowlist Known valid model ids.
 * @returns A user-facing error string.
 *
 * @example
 * ```ts
 * const message = formatInvalidModelError(["openai/gpt5.4"], ["openai/gpt-5.4"]);
 * ```
 */
function formatInvalidModelError(invalidModels: string[], allowlist: string[]): string {
  const [firstInvalidModel] = invalidModels;
  const suggestions = suggestModels(firstInvalidModel, allowlist);
  const suggestionText =
    suggestions.length > 0
      ? ` Did you mean ${suggestions.map((item) => `'${item}'`).join(" or ")}?`
      : " Run `opencode models` and try again.";

  if (invalidModels.length === 1) {
    return `Error: Model name '${firstInvalidModel}' not found.${suggestionText}`;
  }

  return `Error: Model names not found: ${invalidModels.map((item) => `'${item}'`).join(", ")}.${suggestionText}`;
}

/**
 * Launches an OpenCode command in a tmux window.
 *
 * @param sessionName Existing tmux session name.
 * @param plan Window launch plan.
 * @returns Result describing whether the command was sent successfully.
 *
 * @example
 * ```ts
 * await launchModelInWindow("demo", { model: "openai/gpt-5.4", windowName: "gpt-5-4" });
 * ```
 */
async function launchModelInWindow(sessionName: string, plan: WindowLaunchPlan): Promise<CommandResult> {
  const launchCommand = `opencode --model ${shellQuote(plan.model)}`;

  // Send the exact command text into the pane so tmux keeps the user's normal shell setup.
  return runCommand(["tmux", "send-keys", "-t", `${sessionName}:${plan.windowName}`, launchCommand, "C-m"]);
}

/**
 * Sanitizes a session name to be safe for paths and branch names.
 */
function sanitizeName(name: string): string {
  return name.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
}

/**
 * Generates the full absolute path for a worktree.
 */
function getWorktreePath(safeSession: string, windowName: string): string {
  return path.join(os.homedir(), ".local/share/opencode/multi-model", safeSession, windowName);
}

/**
 * Removes a git worktree and deletes its branch on failure.
 */
async function undoWorktree(worktreePath: string, branchName: string): Promise<string[]> {
  const errors: string[] = [];
  const removeRes = await runCommand(["git", "worktree", "remove", "-f", worktreePath]);
  if (!removeRes.ok) errors.push(`Failed to remove worktree ${worktreePath}: ${removeRes.stderr}`);
  
  const branchRes = await runCommand(["git", "branch", "-D", branchName]);
  if (!branchRes.ok) errors.push(`Failed to delete branch ${branchName}: ${branchRes.stderr}`);
  return errors;
}

export default tool({
  description: "Launch multiple OpenCode models in tmux",
  args: {
    sessionName: tool.schema.string().min(1).describe("tmux session name to create"),
    models: tool.schema
      .array(tool.schema.string().min(1))
      .min(1)
      .describe("one or more OpenCode model ids to launch"),
  },
  async execute(args, context) {
    const sessionName = args.sessionName.trim();
    const safeSessionName = sanitizeName(sessionName);
    const models = normalizeModels(args.models);

    if (!sessionName) {
      return "Error: `sessionName` must not be empty.";
    }

    if (models.length === 0) {
      return "Error: Model names must not be empty.";
    }

    const duplicateModels = findDuplicates(models);
    if (duplicateModels.length > 0) {
      return `Error: Duplicate model names are not allowed: ${duplicateModels.map((item) => `'${item}'`).join(", ")}.`;
    }

    const gitRepoCheck = await runCommand(["git", "rev-parse", "--is-inside-work-tree"]);
    if (!gitRepoCheck.ok) {
      return "Error: `multi-model` requires a git repository.";
    }

    const tmuxExists = await runCommand(["command", "-v", "tmux"]);
    if (!tmuxExists.ok) {
      return "Error: `tmux` is not installed or not on `PATH`.";
    }

    const opencodeExists = await runCommand(["command", "-v", "opencode"]);
    if (!opencodeExists.ok) {
      return "Error: `opencode` is not installed or not on `PATH`.";
    }

    const modelListResult = await runCommand(["opencode", "models"]);
    if (!modelListResult.ok) {
      return `Error: Failed to load valid models from \`opencode models\`${modelListResult.stderr ? `: ${modelListResult.stderr}` : "."}`;
    }

    const allowlist = modelListResult.stdout
      .split(/\r?\n/)
      .map((line) => line.trim())
      .filter(Boolean);

    const invalidModels = models.filter((model) => !allowlist.includes(model));
    if (invalidModels.length > 0) {
      return formatInvalidModelError(invalidModels, allowlist);
    }

    const sessionExists = await runCommand(["tmux", "has-session", "-t", sessionName]);
    if (sessionExists.ok) {
      return "Error: Session already exists. Use a different `sessionName`.";
    }

    const windowPlans = createWindowPlans(models);
    const succeededModels: string[] = [];
    const failedModels: string[] = [];

    for (let i = 0; i < windowPlans.length; i++) {
      const plan = windowPlans[i];
      const isFirst = i === 0;

      const worktreePath = getWorktreePath(safeSessionName, plan.windowName);
      const branchName = `opencode/${safeSessionName}/${plan.windowName}`;

      if (fs.existsSync(worktreePath)) {
        if (!isFirst) {
          failedModels.push(`${plan.model} (Worktree path already exists at ${worktreePath})`);
          continue;
        } else {
          return `Error: Worktree path already exists at ${worktreePath}. Clean it up first.`;
        }
      }

      const branchExists = await runCommand(["git", "show-ref", "--verify", "--quiet", `refs/heads/${branchName}`]);
      if (branchExists.ok) {
        if (!isFirst) {
          failedModels.push(`${plan.model} (Branch '${branchName}' already exists)`);
          continue;
        } else {
          return `Error: Branch '${branchName}' already exists.`;
        }
      }

      const worktreeResult = await runCommand(["git", "worktree", "add", "-b", branchName, worktreePath]);
      if (!worktreeResult.ok) {
        if (!isFirst) {
          failedModels.push(`${plan.model} (Failed to create worktree: ${worktreeResult.stderr})`);
          continue;
        } else {
          return `Error: Failed to create worktree for ${plan.model}: ${worktreeResult.stderr}`;
        }
      }

      if (isFirst) {
        const sessionCreateResult = await runCommand([
          "tmux",
          "new-session",
          "-d",
          "-s",
          sessionName,
          "-n",
          plan.windowName,
          "-c",
          worktreePath,
        ]);

        if (!sessionCreateResult.ok) {
          const undoErrors = await undoWorktree(worktreePath, branchName);
          let errorMsg = `Error: Failed to create tmux session '${sessionName}'.${sessionCreateResult.stderr ? ` ${sessionCreateResult.stderr}` : ""}`;
          if (undoErrors.length > 0) errorMsg += ` Cleanup errors: ${undoErrors.join(", ")}`;
          return errorMsg;
        }
      } else {
        const windowCreateResult = await runCommand([
          "tmux",
          "new-window",
          "-d",
          "-t",
          sessionName,
          "-n",
          plan.windowName,
          "-c",
          worktreePath,
        ]);

        if (!windowCreateResult.ok) {
          failedModels.push(`${plan.model} (${windowCreateResult.stderr || "failed to create window"})`);
          const undoErrors = await undoWorktree(worktreePath, branchName);
          if (undoErrors.length > 0) failedModels.push(`cleanup failed for ${plan.model}: ${undoErrors.join(", ")}`);
          continue;
        }
      }

      const launchResult = await launchModelInWindow(sessionName, plan);
      if (launchResult.ok) {
        succeededModels.push(plan.model);
      } else {
        failedModels.push(`${plan.model} (${launchResult.stderr || "failed to send launch command"})`);
        const undoErrors = await undoWorktree(worktreePath, branchName);
        if (undoErrors.length > 0) failedModels.push(`cleanup failed for ${plan.model}: ${undoErrors.join(", ")}`);
      }
    }

    const attachCommand = `tmux attach -t ${sessionName}`;
    const cleanupCommand = `tmux kill-session -t ${sessionName} && rm -rf ~/.local/share/opencode/multi-model/${safeSessionName} && git worktree prune && git branch -D $(git branch --format='%(refname:short)' --list 'opencode/${safeSessionName}/*')`;

    context.metadata({
      title: `multi-model ${sessionName}`,
      metadata: {
        safeSessionName,
        modelCount: models.length,
      },
    });

    if (failedModels.length > 0) {
      return [
        `Error: Created tmux session '${sessionName}', but some model launches failed.`,
        `Succeeded: ${succeededModels.length > 0 ? succeededModels.join(", ") : "none"}.`,
        `Failed: ${failedModels.join(", ")}.`,
        `Attach with \`${attachCommand}\` to inspect the session.`,
        `Cleanup with \n\`${cleanupCommand}\`\nwhen done.`
      ].join("\n");
    }

    return [
      `Use \`${attachCommand}\` to join session.`,
      `When finished, clean up worktrees with:`,
      `\`${cleanupCommand}\``
    ].join("\n");
  },
});