ui.ts

import chalk from "chalk";
import type { Session, Agent, SearchResult } from "./types";

export function formatSession(session: Session, index?: number): string {
  const prefix = index !== undefined ? chalk.dim(`${index + 1}.`) : "";
  const id = chalk.cyan(session.id.slice(0, 8));
  const project = chalk.yellow(session.project);
  const time = formatRelativeTime(session.modifiedAt);
  const msgs = chalk.dim(`${session.messageCount} msgs`);
  const preview = chalk.white(truncate(session.firstMessage, 60));

  return `${prefix} ${id} ${project} ${chalk.dim("•")} ${time} ${chalk.dim("•")} ${msgs}
   ${preview}`;
}

export function formatSearchResult(result: SearchResult, index: number): string {
  const score = chalk.green(`${(1 - result.score).toFixed(0)}%`);
  const id = chalk.cyan(result.session.id.slice(0, 8));
  const project = chalk.yellow(result.session.project);
  const preview = chalk.white(truncate(result.matchedContent, 80));
  const relevance = getRelevanceHint(result);

  return `${chalk.dim(`${index + 1}.`)} ${score} ${id} ${project}
   ${preview}
   ${chalk.dim(relevance)}`;
}

function getRelevanceHint(result: SearchResult): string {
  if (!result.query) {
    return "Semantic match";
  }

  const contentLower = result.matchedContent.toLowerCase();
  const queryTerms = result.query
    .toLowerCase()
    .split(/\s+/)
    .filter((t) => t.length > 2);

  // Find exact term matches
  const exactMatches = queryTerms.filter((term) => contentLower.includes(term));

  if (exactMatches.length > 0) {
    return `✓ Contains: ${exactMatches.join(", ")}`;
  }

  // Find semantic concepts by checking for related words
  const conceptMap: Record<string, string[]> = {
    backup: ["backup", "save", "restore", "copy", "sync"],
    deploy: ["deploy", "release", "push", "ship", "launch"],
    error: ["error", "bug", "issue", "fail", "crash", "exception"],
    performance: [
      "performance",
      "speed",
      "slow",
      "optimize",
      "fast",
      "latency",
    ],
    security: ["security", "auth", "password", "token", "encrypt", "ssl"],
    database: ["database", "db", "sql", "query", "table", "index"],
    api: ["api", "endpoint", "request", "response", "http", "rest"],
    testing: ["test", "unit", "integration", "jest", "vitest", "debug"],
  };

  const foundConcepts: string[] = [];
  for (const [concept, keywords] of Object.entries(conceptMap)) {
    const queryHasKeyword = queryTerms.some((term) => keywords.includes(term));
    const contentHasKeyword = keywords.some((keyword) =>
      contentLower.includes(keyword)
    );

    if (queryHasKeyword && contentHasKeyword) {
      foundConcepts.push(concept);
    }
  }

  if (foundConcepts.length > 0) {
    return `→ Related concepts: ${foundConcepts.join(", ")}`;
  }

  return "→ Semantic similarity (meaning-based match)";
}

export function formatAgent(agent: Agent): string {
  const name = chalk.cyan.bold(agent.name);
  const desc = chalk.white(agent.description);
  const tools = chalk.dim(agent.tools.join(", "));

  return `${name} - ${desc}
   ${chalk.dim("Tools:")} ${tools}`;
}

export function formatAgentChoice(agent: Agent): { name: string; value: string } {
  return {
    name: `${chalk.cyan.bold(agent.name.padEnd(12))} ${chalk.dim(agent.description)}`,
    value: agent.name,
  };
}

export function formatSessionChoice(session: Session): { name: string; value: string } {
  const time = formatRelativeTime(session.modifiedAt);
  const project = session.project.padEnd(20).slice(0, 20);
  const preview = truncate(session.firstMessage, 50);

  return {
    name: `${chalk.yellow(project)} ${chalk.dim(time.padEnd(12))} ${preview}`,
    value: session.id,
  };
}

export function header(text: string): void {
  console.log();
  console.log(chalk.bold.blue(`◆ ${text}`));
  console.log(chalk.dim("─".repeat(50)));
}

export function success(text: string): void {
  console.log(chalk.green(`✓ ${text}`));
}

export function error(text: string): void {
  console.log(chalk.red(`✗ ${text}`));
}

export function info(text: string): void {
  console.log(chalk.dim(`  ${text}`));
}

export function highlight(text: string): string {
  return chalk.cyan.bold(text);
}

function truncate(text: string, length: number): string {
  const clean = text.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
  if (clean.length <= length) return clean;
  return clean.slice(0, length - 1) + "…";
}

function formatRelativeTime(date: Date): string {
  const now = new Date();
  const diffMs = now.getTime() - date.getTime();
  const diffMins = Math.floor(diffMs / 60000);
  const diffHours = Math.floor(diffMins / 60);
  const diffDays = Math.floor(diffHours / 24);

  if (diffMins < 1) return "just now";
  if (diffMins < 60) return `${diffMins}m ago`;
  if (diffHours < 24) return `${diffHours}h ago`;
  if (diffDays < 7) return `${diffDays}d ago`;
  if (diffDays < 30) return `${Math.floor(diffDays / 7)}w ago`;
  return date.toLocaleDateString();
}