import { runSetup } from "./commands/setup.js";
import { listModels, listTuis } from "./commands/list.js";
import { runBench } from "./commands/bench.js";
import { runDefault } from "./commands/run.js";
import { showStatus } from "./commands/status.js";
import { startServers, stopServers } from "./commands/server.js";
import { runPipe } from "./commands/pipe.js";
import { runAsk } from "./commands/ask.js";
import { getTuiById } from "./registry/tuis.js";
import { getModelById } from "./registry/models.js";

const BOLD = "\x1b[1m";
const DIM = "\x1b[2m";
const RESET = "\x1b[0m";

function printUsage(): void {
  console.log(`
${BOLD}localcode${RESET} — local AI coding environment (Ollama)

${BOLD}Launch:${RESET}
  localcode                                 Launch with defaults
  localcode <tui>                           Launch with specified TUI
  localcode <model>                         Launch with specified model
  localcode <tui> <model>                   Launch with both overrides

${BOLD}Server:${RESET}
  localcode start                           Start Ollama + pull models
  localcode stop                            Stop Ollama
  localcode status                          Show config and server health

${BOLD}List:${RESET}
  localcode models                          List available models
  localcode tuis                            List available TUIs

${BOLD}Benchmark:${RESET}
  localcode bench                           Benchmark the running chat model
  localcode bench history                   Show past benchmark results

${BOLD}Quick:${RESET}
  localcode ask "question"                  Quick coding Q&A (streamed)
  localcode pipe "prompt"                   Pipe stdin through the model

${BOLD}Other:${RESET}
  localcode setup                           Full install (Ollama, models, tools)
`);
}

interface LaunchOverrides {
  model?: string;
  tui?: string;
  passthrough: string[];
}

function parseLaunchArgs(argv: string[]): LaunchOverrides {
  const overrides: LaunchOverrides = { passthrough: [] };
  for (const arg of argv) {
    if (getTuiById(arg)) {
      overrides.tui = arg;
    } else if (getModelById(arg)) {
      overrides.model = arg;
    } else {
      overrides.passthrough.push(arg);
    }
  }
  return overrides;
}

async function main(): Promise<void> {
  const cmd = process.argv[2];

  switch (cmd) {
    case "status":
      await showStatus();
      break;

    case "start":
      await startServers();
      break;

    case "stop":
      stopServers();
      break;

    case "models":
      listModels();
      break;

    case "tuis":
      listTuis();
      break;

    case "bench": {
      const sub = process.argv[3];
      if (sub === "history") {
        await runBench(["--history"]);
      } else {
        await runBench(process.argv.slice(3));
      }
      break;
    }

    case "ask": {
      const question = process.argv.slice(3).join(" ");
      if (!question) {
        console.error("Usage: localcode ask \"question\"");
        process.exit(1);
      }
      await runAsk(question);
      break;
    }

    case "pipe": {
      const prompt = process.argv[3] ?? "Improve this code";
      await runPipe(prompt);
      break;
    }

    case "setup":
      await runSetup();
      break;

    case "help":
    case "--help":
    case "-h":
      printUsage();
      break;

    default: {
      // Everything else is a launch command with optional overrides:
      //   localcode
      //   localcode tui aider
      //   localcode model qwen3-coder
      //   localcode model qwen3-coder tui goose
      const args = process.argv.slice(2);
      const overrides = parseLaunchArgs(args);
      await runDefault(overrides);
      break;
    }
  }
}

main().catch((e: unknown) => {
  console.error(e);
  process.exit(1);
});