import * as fs from 'fs';
import * as path from 'path';
import {
  isStarterTemplateName,
  listStarterTemplates,
  parseOutcomeYaml,
  persistDeployment,
  simulateOutcomeRun,
  validateOutcomeYaml,
  writeStarterTemplate,
} from '../byo';
import { green, yellow, dim } from './colors';

export async function runByoInit(argv: string[]): Promise<number> {
  const template = argv[0];
  const force = argv.includes('--force');
  const output = valueAfter(argv, '--output') ?? 'outcome.yaml';
  if (!isStarterTemplateName(template)) {
    process.stderr.write(`agentguard init: unknown template '${template ?? ''}'\n`);
    process.stderr.write('available templates: ' + listStarterTemplates().join(', ') + '\n');
    return 2;
  }
  try {
    const file = writeStarterTemplate(template, path.resolve(output), force);
    process.stdout.write(`${green('+ created')} ${path.relative(process.cwd(), file) || file}\n`);
    process.stdout.write(`${dim('next:')} agentguard run ${template} --inputs '{"task_id":"demo","payload_ref":"local-file"}'\n`);
    return 0;
  } catch (err) {
    process.stderr.write(`agentguard init: ${err instanceof Error ? err.message : String(err)}\n`);
    return 1;
  }
}

export async function runOutcome(argv: string[]): Promise<number> {
  const slug = argv[0];
  if (!slug || argv.includes('--help') || argv.includes('-h')) {
    process.stdout.write("agentguard run <slug> --inputs '{...}' [--config ./outcome.yaml]\n");
    return slug ? 0 : 2;
  }
  const configPath = path.resolve(valueAfter(argv, '--config') ?? 'outcome.yaml');
  const inputsRaw = valueAfter(argv, '--inputs') ?? '{}';
  let inputs: Record<string, unknown>;
  try {
    inputs = JSON.parse(inputsRaw) as Record<string, unknown>;
  } catch {
    process.stderr.write('agentguard run: --inputs must be valid JSON\n');
    return 2;
  }
  const loaded = loadConfig(configPath);
  if (!loaded.ok) return loaded.code;
  if (loaded.config.slug !== slug) {
    process.stderr.write(`agentguard run: config slug is ${loaded.config.slug}, not ${slug}\n`);
    return 2;
  }
  process.stdout.write(JSON.stringify(simulateOutcomeRun(loaded.config, inputs), null, 2) + '\n');
  return 0;
}

export async function runDeploy(argv: string[]): Promise<number> {
  const configPath = path.resolve(valueAfter(argv, '--config') ?? 'outcome.yaml');
  const loaded = loadConfig(configPath);
  if (!loaded.ok) return loaded.code;
  const file = persistDeployment(loaded.config);
  process.stdout.write(`${green('+ deployed')} ${loaded.config.slug} ${dim('local config only')}\n`);
  process.stdout.write(`${dim('receipt config:')} ${path.relative(process.cwd(), file) || file}\n`);
  return 0;
}

function loadConfig(configPath: string): { ok: true; config: ReturnType<typeof parseOutcomeYaml> } | { ok: false; code: number } {
  if (!fs.existsSync(configPath)) {
    process.stderr.write(`agentguard: missing ${configPath}. Run agentguard init <template> first.\n`);
    return { ok: false, code: 2 };
  }
  const source = fs.readFileSync(configPath, 'utf8');
  const validated = validateOutcomeYaml(source);
  if (!validated.ok || !validated.config) {
    process.stderr.write(`${yellow('invalid outcome.yaml')}\n`);
    for (const error of validated.errors) process.stderr.write(`  ${error}\n`);
    return { ok: false, code: 2 };
  }
  return { ok: true, config: validated.config };
}

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