/**
 * ai command
 * AI prompt building and suggestion commands
 * Generated from SpecVerse specification
 */

import { Command } from 'commander';

import { readFileSync, writeFileSync, existsSync, mkdirSync, cpSync, rmSync, statSync, readdirSync } from 'fs';
import { resolve, basename } from 'path';
import { EngineRegistry } from '@specverse/entities';
import type { ParserEngine } from '@specverse/types';




/**
 * Register the ai command on the program.
 */
export function registerAiCommand(program: Command): void {
  const cmd = program
    .command('ai')
    .description('AI prompt building and suggestion commands');

  cmd
    .command('docs <file>')
    .description('Generate AI documentation prompts from specification')
    .option('-o, --output <output>', 'Output file path')
    .option('--config <config>', 'Configuration file with requirements, scale, etc.')
    .action(async (file: string,  options: any) => {
      try {
        const registry = new EngineRegistry();
        await registry.discover();
        const parser = registry.getEngineForCapability('parse') as ParserEngine;
        if (!parser) { console.error('No parser engine found.'); process.exit(1); }
        await parser.initialize();

        const content = readFileSync(file, 'utf8');
        const parseResult = parser.parseContent(content, file);
        if (parseResult.errors.length > 0) {
          console.error('Invalid spec:');
          parseResult.errors.forEach((e: string) => console.error(' ', e));
          process.exit(1);
        }

        const aiEngine = registry.getEngineForCapability('ai-prompts') as any;
        if (!aiEngine) {
          console.error('AI engine not available. Install @specverse/engines.');
          process.exit(1);
        }
        await aiEngine.initialize({ provider: options.provider });
        const prompt = await aiEngine.generatePrompt(parseResult.ast!, { type: 'docs' });
        const outputFile = options.output || basename(file, '.specly') + '-ai-docs.md';
        writeFileSync(outputFile, prompt);
        console.log('AI documentation prompt generated: ' + outputFile);
      } catch (error: any) {
        console.error('Error:', error.message);
        process.exit(1);
      }
    });

  cmd
    .command('suggest <file>')
    .description('Get AI suggestions for improving a specification')

    .action(async (file: string,  _options: any) => {
      try {
        const registry = new EngineRegistry();
        await registry.discover();
        const parser = registry.getEngineForCapability('parse') as ParserEngine;
        if (!parser) { console.error('No parser engine found.'); process.exit(1); }
        await parser.initialize();

        const content = readFileSync(file, 'utf8');
        const parseResult = parser.parseContent(content, file);
        if (parseResult.errors.length > 0) {
          console.error('Invalid spec:');
          parseResult.errors.forEach((e: string) => console.error(' ', e));
          process.exit(1);
        }

        const aiEngine = registry.getEngineForCapability('ai-suggestions') as any;
        if (!aiEngine) {
          console.error('AI engine not available. Install @specverse/engines.');
          process.exit(1);
        }
        await aiEngine.initialize();
        const suggestions = await aiEngine.suggest(parseResult.ast!);
        if (suggestions.length === 0) {
          console.log('No suggestions — spec looks good!');
        } else {
          const warnings = suggestions.filter((s: any) => s.severity === 'warning');
          const improvements = suggestions.filter((s: any) => s.severity === 'improvement');
          const info = suggestions.filter((s: any) => s.severity === 'info');
          if (warnings.length > 0) {
            console.log('\nWarnings:');
            warnings.forEach((s: any) => console.log('  [' + s.target + '] ' + s.description));
          }
          if (improvements.length > 0) {
            console.log('\nSuggested improvements:');
            improvements.forEach((s: any) => console.log('  [' + s.target + '] ' + s.description));
          }
          if (info.length > 0) {
            console.log('\nInfo:');
            info.forEach((s: any) => console.log('  [' + s.target + '] ' + s.description));
          }
          console.log('\n' + suggestions.length + ' suggestion(s): ' + warnings.length + ' warning, ' + improvements.length + ' improvement, ' + info.length + ' info');
        }
      } catch (error: any) {
        console.error('Error:', error.message);
        process.exit(1);
      }
    });

  cmd
    .command('template <operation>')
    .description('Generate AI implementation templates')
    .option('-o, --output <output>', 'Output file path')
    .option('--config <config>', 'Configuration file')
    .action(async (operation: string,  options: any) => {
      try {
        const registry = new EngineRegistry();
        await registry.discover();
        const aiEngine = registry.getEngineForCapability('ai-templates') as any;
        if (!aiEngine) {
          console.error('AI engine not available. Install @specverse/engines.');
          process.exit(1);
        }
        await aiEngine.initialize();
        const template = await aiEngine.template(operation, { config: options.config });
        if (options.output) {
          writeFileSync(options.output, template);
          console.log('Template written to: ' + options.output);
        } else {
          console.log(template);
        }
      } catch (error: any) {
        console.error('Error:', error.message);
        process.exit(1);
      }
    });

  cmd
    .command('regenerate <fn>')
    .description('Regenerate an AI-generated behavior function for a controller or service')
    .option('--spec <spec>', 'Spec file (default: specs/main-inferred.specly, fallback specs/main.specly)')
    .option('-o, --output <output>', 'Output root (default: generated/code)')
    .option('--all', 'Regenerate every AI-generated function for the owner (not just one)', false)
    .action(async (fn: string,  options: any) => {
      try {
        // Parse Owner.functionName — or just Owner with --all
        const target = fn;
        const dotIdx = target.indexOf('.');
        const ownerName = dotIdx >= 0 ? target.slice(0, dotIdx) : target;
        const functionName = dotIdx >= 0 ? target.slice(dotIdx + 1) : null;
        if (!functionName && !options.all) {
          console.error('Function must be specified as Owner.functionName, or use --all to regenerate every AI function in the owner.');
          process.exit(1);
        }

        // Resolve spec file — default to specs/main-inferred.specly next to cwd
        const userCwd = process.env.SPECVERSE_USER_CWD || process.cwd();
        const specCandidates = options.spec
          ? [resolve(userCwd, options.spec)]
          : [resolve(userCwd, 'specs/main-inferred.specly'), resolve(userCwd, 'specs/main.specly')];
        const specPath = specCandidates.find(p => existsSync(p));
        if (!specPath) {
          console.error('Spec not found. Tried: ' + specCandidates.join(', '));
          console.error('Pass --spec <file> or run from a project root with specs/main.specly.');
          process.exit(1);
        }
        console.log('Using spec: ' + specPath);

        const registry = new EngineRegistry();
        await registry.discover();
        const parser = registry.getEngineForCapability('parse') as ParserEngine;
        if (!parser) { console.error('No parser engine found.'); process.exit(1); }
        await parser.initialize();

        const specContent = readFileSync(specPath, 'utf8');
        const parseResult = parser.parseContent(specContent, specPath);
        if (parseResult.errors.length > 0) {
          console.error('Invalid spec:');
          parseResult.errors.forEach((e: string) => console.error('  ' + e));
          process.exit(1);
        }

        // Flatten components down to a realize-shaped spec
        // (controllers, services, models at top level) — matches what
        // regenerateBehavior expects. Collections may be arrays (parser
        // output) or objects (inferred spec); preserve the incoming shape.
        const ast: any = parseResult.ast;
        const flat: any = { ...ast };
        const components = ast?.components || {};
        for (const comp of Object.values(components) as any[]) {
          for (const key of ['models', 'controllers', 'services']) {
            const collection = comp?.[key];
            if (!collection) continue;
            if (Array.isArray(collection)) {
              flat[key] = [...(Array.isArray(flat[key]) ? flat[key] : []), ...collection];
            } else {
              flat[key] = { ...(flat[key] && !Array.isArray(flat[key]) ? flat[key] : {}), ...collection };
            }
          }
        }

        const { regenerateBehavior } = await import('@specverse/engines/ai');
        const outputDir = resolve(userCwd, options.output || 'generated/code');
        try {
          const result = await regenerateBehavior({
            spec: flat,
            ownerName,
            targetFunction: options.all ? null : functionName,
            outputDir,
            allFunctions: !!options.all,
          });
          console.log(`✅ Regenerated ${result.filePath}`);
          console.log(`   Owner: ${ownerName}`);
          console.log(`   Unmatched functions: ${result.unmatchedCount}`);
          console.log(`   Target: ${options.all ? 'all' : functionName}`);
          console.log(`   Cache entries cleared: ${result.cacheCleared}`);
        } catch (err: any) {
          console.error('Regeneration failed: ' + (err?.message || err));
          process.exit(1);
        }
      } catch (error: any) {
        console.error('Error:', error.message);
        process.exit(1);
      }
    });

  cmd
    .command('analyse <source>')
    .description('Analyse a source codebase and extract a SpecVerse spec via the LLM. Writes a structured run dir (input/, facts/, prompts/, llm-output/, specs/, project/).')
    .option('-o, --output <output>', 'Output dir for the structured run (default: ./runs/analyse/<source-basename>/<date>_<label>/)')
    .option('--facts <facts>', 'Inject pre-extracted structural facts (markdown) as the prompt preamble')
    .option('--no-auto-facts', 'Auto-extract structural facts via runPrepass before calling analyse (use --no-auto-facts to opt out)')
    .option('--scope <scope>', 'Comma-separated source subdirectories to analyse (e.g. server,shared,client) — narrows a large/messy repo to its real source. Root config files (package.json, tsconfig, *.config.*, schema.prisma) are always included. Omit to analyse the whole source (still skipping non-source noise).')
    .option('--verify', 'Run the rule-driven quality verify after the draft (re-fire low-quality action bodies)', false)
    .option('--realize', 'After validation, materialize project/ via spv init + spv realize all', false)
    .option('--label <label>', 'Run-folder label (default: prompt+provider+model)')
    .option('--session-id <session-id>', 'Externally-managed claude-cli session UUID (cross-process coordination — typically set via SPECVERSE_AI_SESSION_ID env var, not on the command line).')
    .option('--no-behaviours', 'Run the LLM behaviours phase to fill action bodies. Use --no-behaviours to emit only the deterministic skeleton (fast iteration; run `spv ai behaviours` later to fill bodies).')
    .action(async (source: string,  options: any) => {
      try {
        // Resolve the absolute source dir.
        const userCwd = process.env.SPECVERSE_USER_CWD || process.cwd();
        const sourceAbs = resolve(userCwd, source);
        if (!existsSync(sourceAbs)) {
          console.error('Source dir not found: ' + sourceAbs);
          process.exit(1);
        }

        // Default output: ./runs/analyse/<basename>/<date>_<label>/
        const { runAnalyse, buildRunFolder, caseRunPath, ensureSubdirs, inputDir, resolveProviderId } = await import('@specverse/engines/ai');
        const { renderGitnexusignore, isAnalyseConfigFile, hasExistingGitnexusIndex, buildSourceVersion } = await import('@specverse/engines/analyse-prepass');
        // --scope: comma-separated source subdirs that narrow a large/messy
        // repo to its real source (e.g. server,shared,client). Empty = whole source.
        const scope = (options.scope ? String(options.scope).split(',') : [])
          .map((s: string) => s.trim().replace(/^[./]+|\/+$/g, '')).filter(Boolean);
        const providerId = resolveProviderId();
        const modelId = process.env.SPECVERSE_AI_MODEL || 'default';
        const runFolder = buildRunFolder({
          prompt: 'analyse-v9',
          providerId,
          modelId,
          label: options.label,
        });
        const outputDir = options.output
          ? resolve(userCwd, options.output)
          : caseRunPath(userCwd, 'analyse', basename(sourceAbs), runFolder);
        ensureSubdirs(outputDir);

        const inDir = inputDir(outputDir);
        const stat = statSync(sourceAbs);
        const sourceIsInput = sourceAbs === inDir;

        // Mode — use a STANDARD gitnexus index in the GLOBAL registry (attach if
        // one exists, else create one the user's own gitnexus/MCP/IDE can reuse)
        // when the source is a real external dir; --scope is applied at the
        // facts layer so it composes with attach. Otherwise ISOLATE (copy into
        // input/ + a private per-run index). The batch/eval path always isolates
        // — a pre-staged input/ (sourceIsInput) or SPECVERSE_ANALYSE_ISOLATED=1
        // — so concurrent runs never race the shared registry.
        const forceIsolate = sourceIsInput || process.env.SPECVERSE_ANALYSE_ISOLATED === '1';
        const attach = stat.isDirectory() && !forceIsolate;
        const analyseSourceDir = attach ? sourceAbs : inDir;
        // Captured BEFORE runAnalyse (which creates the index) so the mode log
        // + provenance can tell attach-existing from create-standard.
        const preExistingIndex = attach && hasExistingGitnexusIndex(sourceAbs);

        if (!attach) {
          // Copy source into outputDir/input/ (excluding noisy indices) so the
          // run dir is self-contained. (Skip when sourceAbs IS already input/ —
          // an orchestrator pre-staged it.)
          if (stat.isDirectory() && !sourceIsInput) {
            if (existsSync(inDir)) {
              try {
                if (scope.length > 0) {
                  // --scope: copy ONLY the named subtrees + root config files
                  // (framework/ORM signals the prepass keys on); leave the rest
                  // (root debug scripts, sibling apps, dumps) out.
                  mkdirSync(inDir, { recursive: true });
                  for (const sub of scope) {
                    const subAbs = resolve(sourceAbs, sub);
                    if (existsSync(subAbs)) cpSync(subAbs, resolve(inDir, sub), { recursive: true, force: true });
                    else console.warn('  scope: "' + sub + '" not found in source — skipping');
                  }
                  for (const entry of readdirSync(sourceAbs)) {
                    if (!isAnalyseConfigFile(entry)) continue;
                    const f = resolve(sourceAbs, entry);
                    try { if (statSync(f).isFile()) cpSync(f, resolve(inDir, entry)); } catch {}
                  }
                } else {
                  cpSync(sourceAbs, inDir, { recursive: true, force: true });
                }
              }
              catch (err: any) {
                console.error('Failed to copy source into input/: ' + err.message);
                process.exit(1);
              }
            }
          } else if (!stat.isDirectory()) {
            // Single-file source — copy into input/, UNLESS it already lives
            // there (an orchestrator pre-staged input/<file>; a file path is
            // never === inDir, so guard cpSync(X, X) → "src and dest cannot be
            // the same").
            const fileTarget = resolve(inDir, basename(sourceAbs));
            if (resolve(sourceAbs) !== fileTarget) {
              mkdirSync(inDir, { recursive: true });
              cpSync(sourceAbs, fileTarget);
            }
          }
          // Strip noise from the copy; also .git so gitnexus registers under our
          // --name rather than the source repo's identity.
          for (const noise of ['.gitnexus', '.git', 'node_modules', '.DS_Store']) {
            const p = resolve(inDir, noise);
            try { if (existsSync(p)) rmSync(p, { recursive: true, force: true }); } catch {}
          }
          // Skip non-source noise so the isolated index indexes signal, not a
          // multi-GB tree (gitnexus honours .gitnexusignore; the listFiles walk
          // applies the same shared policy directly).
          try {
            writeFileSync(resolve(inDir, '.gitnexusignore'), renderGitnexusignore());
          } catch {}
        }

        console.log('  source:  ' + sourceAbs);
        console.log('  output:  ' + outputDir);
        console.log('  provider: ' + providerId);
        console.log('  mode:     ' + (attach ? (preExistingIndex ? 'attach (existing standard index)' : 'create standard index, then attach') : 'isolate (copy + private index)'));
        // Provenance — record which source version is analysed (git commit for a
        // real repo; null for a plain dir). Supersedes the copy-hash fingerprint.
        try {
          const provMode = attach ? (preExistingIndex ? 'attach' : 'create-standard') : 'isolate';
          writeFileSync(resolve(outputDir, 'facts', 'source-version.json'),
            JSON.stringify(buildSourceVersion(sourceAbs, { mode: provMode, scope }), null, 2));
        } catch {}
        if (options.facts) console.log('  facts:    ' + options.facts);
        if (options.autoFacts) console.log('  facts:    auto (runPrepass)');
        if (options.verify) console.log('  verify:   enabled');
        if (options.realize) console.log('  realize:  enabled');

        try {
          const result = await runAnalyse({
            sourceDir: analyseSourceDir,
            attach,
            scope: scope.length > 0 ? scope : undefined,
            outputDir,
            factsPath: options.facts ? resolve(userCwd, options.facts) : undefined,
            autoFacts: !!options.autoFacts,
            verify: !!options.verify,
            realize: !!options.realize,
            sessionId: options.sessionId,
            // useMicrocalls deliberately omitted: engines defaults to the
            // skeleton + per-action micro-calls path when prepassFacts are
            // available (autoFacts: true). The legacy --microcalls /
            // --no-microcalls CLI flag was retired in self 5.18.1.
            withBehaviours: options.behaviours !== false,
            prompt: 'analyse-v9',
            providerId,
            modelId,
            caseName: basename(sourceAbs),
          });
          console.log('');
          console.log('✅ Analyse complete');
          console.log('   Final spec: ' + result.finalSpecPath);
          console.log('   Validate:   ' + (result.validateFinal.ok ? '✓ pass' : '✗ ' + result.validateFinal.errors.slice(0, 100)));
          if (result.realize) {
            console.log('   Realize:    ' + (result.realize.ok ? '✓ project/ materialized' : '✗ ' + result.realize.error));
          }
          console.log('   README:     ' + outputDir + '/README.md');
        } catch (err: any) {
          console.error('Analyse failed: ' + (err?.message || err));
          process.exit(1);
        }
      } catch (error: any) {
        console.error('Error:', error.message);
        process.exit(1);
      }
    });

  cmd
    .command('behaviours <analysedSpecDir>')
    .description('Fill action bodies in an analysed spec via per-action LLM micro-calls. Reads <analysed-spec-dir>/specs/skeleton.specly + facts sidecars produced by `spv ai analyse --no-behaviours`, runs microcalls + surgical retry, writes specs/main.specly.')
    .option('--output, -o <-o>', 'Output dir for the filled spec (default: in-place — same as analysedSpecDir)')
    .option('--concurrency <concurrency>', 'Concurrency cap for per-action micro-calls (default: 5)')
    .option('--session-id <session-id>', 'Externally-managed claude-cli session UUID (~75% input-token savings via session reuse). Picks up SPECVERSE_AI_SESSION_ID env var.')
    .action(async (analysedSpecDir: string,  options: any) => {
      try {
        // Resolve the analysed-spec dir.
        const userCwd = process.env.SPECVERSE_USER_CWD || process.cwd();
        const dirAbs = resolve(userCwd, analysedSpecDir);
        if (!existsSync(dirAbs)) {
          console.error('Analysed spec dir not found: ' + dirAbs);
          process.exit(1);
        }
        if (!statSync(dirAbs).isDirectory()) {
          console.error('analysedSpecDir must be a directory (output of \`spv ai analyse --no-behaviours\`)');
          process.exit(1);
        }

        const { runBehaviours, resolveProviderId } = await import('@specverse/engines/ai');
        const providerId = resolveProviderId();
        const modelId = process.env.SPECVERSE_AI_MODEL || 'default';
        console.log('  analysed-spec-dir: ' + dirAbs);
        console.log('  output-dir:        ' + (options.output ? resolve(userCwd, options.output) : dirAbs));
        console.log('  provider:          ' + providerId + (modelId !== 'default' ? ' (' + modelId + ')' : ''));

        try {
          const result = await runBehaviours({
            analysedSpecDir: dirAbs,
            outputDir: options.output ? resolve(userCwd, options.output) : dirAbs,
            sessionId: options.sessionId,
            microcallConcurrency: options.concurrency ? parseInt(options.concurrency, 10) : undefined,
          });
          console.log('');
          console.log('✅ Behaviours filled');
          console.log('   Filled spec:     ' + result.filledSpecPath);
          console.log('   Microcalls:      ' + result.microcallStats.succeeded + '/' + result.microcallStats.attempted + ' (' + (result.microcallStats.wallTimeMs / 1000).toFixed(1) + 's)');
          if (result.surgicalRetryPasses > 0) {
            console.log('   Surgical retry:  ' + result.surgicalRetryPasses + ' pass(es)');
          }
          console.log('   Validate:        ' + (result.validateFinal.ok ? '✓ pass' : '✗ ' + result.validateFinal.errors.slice(0, 100)));
        } catch (err: any) {
          console.error('Behaviours fill failed: ' + (err?.message || err));
          process.exit(1);
        }
      } catch (error: any) {
        console.error('Error:', error.message);
        process.exit(1);
      }
    });

  cmd
    .command('create [requirements]')
    .description('Generate a SpecVerse spec from a natural-language request via the LLM. Writes a structured run dir (input/, prompts/, llm-output/, specs/, project/).')
    .option('-f, --file <file>', 'Read requirements from a file instead of the positional argument')
    .option('-o, --output <output>', 'Output dir for the structured run (default: ./runs/create/<slug>/<date>_<label>/)')
    .option('--name <name>', 'Short slug for the run-folder name (default: \'spec\')')
    .option('--scale <scale>', 'Scale hint: personal | small | medium | enterprise')
    .option('--preferred-tech <preferred-tech>', 'Preferred technology stack hint (e.g. typescript+nestjs, python+django)')
    .option('--verify', 'Run the verify-create pass after the draft (two-stage)', false)
    .option('--realize', 'After validation, materialize project/ via spv init + spv realize all', false)
    .option('--label <label>', 'Run-folder label (default: prompt+provider+model)')
    .option('--session-id <session-id>', 'Externally-managed claude-cli session UUID — share across multiple invocations to reuse session state. Also picks up SPECVERSE_AI_SESSION_ID env var.')
    .action(async (requirements: string,  options: any) => {
      try {
        const userCwd = process.env.SPECVERSE_USER_CWD || process.cwd();
        // Resolve requirements: positional arg, or read from --file.
        let reqText = requirements;
        if (options.file) {
          const fp = resolve(userCwd, options.file);
          if (!existsSync(fp)) {
            console.error('Requirements file not found: ' + fp);
            process.exit(1);
          }
          reqText = readFileSync(fp, 'utf8');
        }
        if (!reqText || !reqText.trim()) {
          console.error('No requirements provided. Pass them as a positional argument or via --file.');
          process.exit(1);
        }

        const { runCreate, buildRunFolder, caseRunPath, ensureSubdirs, resolveProviderId } = await import('@specverse/engines/ai');
        const providerId = resolveProviderId();
        const modelId = process.env.SPECVERSE_AI_MODEL || 'default';
        const runFolder = buildRunFolder({
          prompt: 'create-v9',
          providerId,
          modelId,
          label: options.label,
        });
        // Default output: ./runs/create/<short-slug>/<date>_<label>/
        const slug = (options.name || 'spec').toLowerCase().replace(/[^a-z0-9-]+/g, '-').slice(0, 40) || 'spec';
        const outputDir = options.output
          ? resolve(userCwd, options.output)
          : caseRunPath(userCwd, 'create', slug, runFolder);
        ensureSubdirs(outputDir);

        console.log('  output:   ' + outputDir);
        console.log('  provider: ' + providerId);
        if (options.scale) console.log('  scale:    ' + options.scale);
        if (options.preferredTech) console.log('  tech:     ' + options.preferredTech);
        if (options.verify) console.log('  verify:   enabled');
        if (options.realize) console.log('  realize:  enabled');

        try {
          const result = await runCreate({
            requirements: reqText,
            scale: options.scale,
            preferredTech: options.preferredTech,
            outputDir,
            verify: !!options.verify,
            realize: !!options.realize,
            sessionId: options.sessionId,
            prompt: 'create-v9',
            providerId,
            modelId,
            caseName: slug,
          });
          console.log('');
          console.log('✅ Create complete');
          console.log('   Final spec: ' + result.finalSpecPath);
          console.log('   Validate:   ' + (result.validateFinal.ok ? '✓ pass' : '✗ ' + result.validateFinal.errors.slice(0, 100)));
          if (result.realize) {
            console.log('   Realize:    ' + (result.realize.ok ? '✓ project/ materialized' : '✗ ' + result.realize.error));
          }
          console.log('   README:     ' + outputDir + '/README.md');
        } catch (err: any) {
          console.error('Create failed: ' + (err?.message || err));
          process.exit(1);
        }
      } catch (error: any) {
        console.error('Error:', error.message);
        process.exit(1);
      }
    });
}