import * as fs from 'fs';
import * as path from 'path';
import * as readline from 'readline';
import { AGENTGUARD_SPEND_VERSION } from '../index';
import { fetchCatalog, getCachedCatalog, syncPricingIntoCostTable, type OpenRouterModel } from '../openrouter-catalog';
import { getModelCost, knownModelCosts } from '../cost-table';
import { TASK_TEMPLATES, getTaskTemplate } from '../templates';
import { agentguardHome, banner, cyanBold, dim, green, statusBar, yellow } from './colors';

export interface ModelRow {
  id: string;
  name: string;
  inputCentsPerMtok: number | null;
  outputCentsPerMtok: number | null;
  capability: string;
}

export function rowsFromCatalog(models: OpenRouterModel[]): ModelRow[] {
  return models.map((model) => {
    const input = Number(model.pricing?.prompt);
    const output = Number(model.pricing?.completion);
    return {
      id: model.id,
      name: model.name ?? model.id,
      inputCentsPerMtok: Number.isFinite(input) ? input * 100 * 1_000_000 : null,
      outputCentsPerMtok: Number.isFinite(output) ? output * 100 * 1_000_000 : null,
      capability: capabilityForModel(model.id),
    };
  });
}

export function rowsFromCostTable(): ModelRow[] {
  return Object.entries(knownModelCosts()).map(([id, cost]) => ({
    id,
    name: id,
    inputCentsPerMtok: cost.inputCentsPerKtok * 1000,
    outputCentsPerMtok: cost.outputCentsPerKtok * 1000,
    capability: capabilityForModel(id),
  }));
}

export function filterRows(rows: ModelRow[], opts: { search?: string; capability?: string; task?: string }): ModelRow[] {
  let out = rows;
  if (opts.task) {
    const template = getTaskTemplate(opts.task);
    if (template) {
      const allowed = new Set(template.allowedModels);
      out = out.filter((row) => allowed.has(row.id) || row.capability === template.requiredCapability);
    }
  }
  if (opts.capability) out = out.filter((row) => row.capability === opts.capability);
  if (opts.search) {
    const needle = opts.search.toLowerCase();
    out = out.filter((row) => row.id.toLowerCase().includes(needle) || row.name.toLowerCase().includes(needle));
  }
  return out.sort((a, b) => displayCost(a) - displayCost(b) || a.id.localeCompare(b.id));
}

export function suggestedAssignments(task: string): Record<string, string[]> {
  const template = getTaskTemplate(task);
  if (!template) return {};
  return {
    primary: [template.primaryModel],
    fallback: [template.fallbackModel],
    allowed: template.allowedModels,
  };
}

export async function runModels(argv: string[]): Promise<number> {
  if (argv.includes('--help') || argv.includes('-h')) {
    console.log('agentguard models [--sync-pricing] [--search <term>] [--capability <tier>] [--task <template>] [--json]');
    return 0;
  }

  const sync = argv.includes('--sync-pricing');
  const json = argv.includes('--json');
  const search = argValue(argv, '--search');
  const capability = argValue(argv, '--capability');
  const task = argValue(argv, '--task');

  if (sync) {
    const result = await syncPricingIntoCostTable({ force: true });
    if (json) {
      console.log(JSON.stringify(result, null, 2));
    } else {
      console.log('');
      console.log('  ' + banner(AGENTGUARD_SPEND_VERSION));
      console.log('');
      console.log(`  ${green('applied')} ${result.count} OpenRouter pricing overrides`);
      console.log(`  ${dim('saved')} ${agentguardHome()}/cost-overrides.json`);
      console.log('');
    }
    return 0;
  }

  const rows = await loadRows();
  const filtered = filterRows(rows, { search, capability, task });
  if (json) {
    console.log(JSON.stringify({ models: filtered, assignments: task ? suggestedAssignments(task) : undefined }, null, 2));
    return 0;
  }

  if (process.stdin.isTTY && !search && !capability && !task) {
    const selected = await interactivePick(filtered);
    if (selected.length > 0) writeSelectedModels(selected);
    return 0;
  }

  printRows(filtered, task);
  return 0;
}

async function loadRows(): Promise<ModelRow[]> {
  const cached = getCachedCatalog();
  if (cached) return rowsFromCatalog(cached.data);
  try {
    const catalog = await fetchCatalog();
    return rowsFromCatalog(catalog.data);
  } catch {
    return rowsFromCostTable();
  }
}

function printRows(rows: ModelRow[], task?: string): void {
  console.log('');
  console.log('  ' + banner(AGENTGUARD_SPEND_VERSION));
  console.log('');
  if (task && TASK_TEMPLATES[task]) {
    const assignment = suggestedAssignments(task);
    console.log('  ' + cyanBold(`task: ${task}`));
    console.log(`  primary: ${assignment.primary?.join(', ') ?? 'n/a'}`);
    console.log(`  fallback: ${assignment.fallback?.join(', ') ?? 'n/a'}`);
    console.log('');
  }
  for (const row of rows.slice(0, 80)) {
    console.log(`  ${green(row.id.padEnd(38))} ${formatCost(row).padEnd(22)} ${dim(row.capability)}`);
  }
  if (rows.length > 80) console.log(`  ${yellow(String(rows.length - 80) + ' more')}  refine with agentguard models --search <term>`);
  console.log('');
  console.log('  ' + statusBar());
  console.log('');
}

async function interactivePick(rows: ModelRow[]): Promise<string[]> {
  const selected = new Set<string>();
  let cursor = 0;
  let filtered = rows.slice(0, 80);
  let query = '';
  readline.emitKeypressEvents(process.stdin);
  if (process.stdin.isTTY) process.stdin.setRawMode(true);

  const render = () => {
    process.stdout.write('\x1b[2J\x1b[H');
    console.log(banner(AGENTGUARD_SPEND_VERSION));
    console.log('');
    console.log(`Search: ${query || dim('press / to filter')}   Selected: ${selected.size}`);
    console.log('');
    filtered.slice(0, 18).forEach((row, index) => {
      const marker = selected.has(row.id) ? '[x]' : '[ ]';
      const pointer = index === cursor ? '>' : ' ';
      console.log(`${pointer} ${marker} ${row.id.padEnd(40)} ${formatCost(row).padEnd(20)} ${row.capability}`);
    });
    console.log('');
    console.log(dim('[/] search  [space] select  [enter] confirm  [q] quit'));
  };

  render();
  return new Promise((resolve) => {
    const onKey = (_chunk: string, key: readline.Key) => {
      if (key.name === 'q' || (key.ctrl && key.name === 'c')) finish([]);
      else if (key.name === 'return') finish([...selected]);
      else if (key.name === 'down') { cursor = Math.min(cursor + 1, Math.max(0, filtered.length - 1)); render(); }
      else if (key.name === 'up') { cursor = Math.max(cursor - 1, 0); render(); }
      else if (key.name === 'space') {
        const row = filtered[cursor];
        if (row) selected.has(row.id) ? selected.delete(row.id) : selected.add(row.id);
        render();
      } else if (key.name === 'backspace') {
        query = query.slice(0, -1);
        filtered = filterRows(rows, { search: query });
        cursor = 0;
        render();
      } else if (key.sequence && key.sequence.length === 1 && key.sequence !== '/') {
        query += key.sequence;
        filtered = filterRows(rows, { search: query });
        cursor = 0;
        render();
      }
    };
    const finish = (value: string[]) => {
      process.stdin.off('keypress', onKey);
      if (process.stdin.isTTY) process.stdin.setRawMode(false);
      process.stdout.write('\n');
      resolve(value);
    };
    process.stdin.on('keypress', onKey);
  });
}

function writeSelectedModels(models: string[]): void {
  const filePath = path.join(agentguardHome(), 'policy.yaml');
  fs.mkdirSync(path.dirname(filePath), { recursive: true });
  let existing = '';
  try { existing = fs.readFileSync(filePath, 'utf8'); } catch { existing = defaultPolicy(); }
  const block = ['allowedModels:', ...models.map((model) => `  - ${model}`)].join('\n') + '\n';
  const next = existing.match(/^allowedModels:/m)
    ? existing.replace(/^allowedModels:\n(?:  - .*\n)*/m, block)
    : existing.trimEnd() + '\n' + block;
  fs.writeFileSync(filePath, next);
  console.log(`${green('saved')} ${filePath}`);
}

function defaultPolicy(): string {
  return 'id: local-policy-v1\nname: Local AgentGuard policy\nversion: 1\neffectiveFrom: "' + new Date().toISOString() + '"\nmode: enforce\nscope:\n  tenantId: local\ncaps:\n  - amountCents: 100\n    window: per_call\n    action: allow\n';
}

function formatCost(row: ModelRow): string {
  if (row.inputCentsPerMtok === null || row.outputCentsPerMtok === null) return '$n/a per 1M';
  return `$${(row.inputCentsPerMtok / 100).toFixed(2)}/$${(row.outputCentsPerMtok / 100).toFixed(2)} per 1M`;
}

function displayCost(row: ModelRow): number {
  return row.inputCentsPerMtok ?? Number.MAX_SAFE_INTEGER;
}

function capabilityForModel(model: string): string {
  if (model.includes('gpt-5') || model.includes('opus') || model.includes('sonnet')) return 'payment_initiate';
  if (model.includes('mini') || model.includes('haiku') || model.includes('flash')) return 'read_only';
  if (getModelCost(model)) return 'data_write';
  return 'read_only';
}

function argValue(argv: string[], flag: string): string | undefined {
  const index = argv.indexOf(flag);
  return index >= 0 ? argv[index + 1] : undefined;
}