/**
 * init command
 * Initialize a new SpecVerse project
 * Generated from SpecVerse specification
 */

import { Command } from 'commander';

import { existsSync, mkdirSync, readdirSync, statSync, readFileSync, writeFileSync } from 'fs';
import { resolve, join, dirname } from 'path';
import { fileURLToPath } from 'url';

interface CommandOptions {
  template?: string;
  list?: boolean;
  static?: boolean;
}



/**
 * Register the init command on the program.
 */
export function registerInitCommand(program: Command): void {
  program
    .command('init [name]')
    .description('Initialize a new SpecVerse project')
    .option('--template <template>', 'Template to use (default, full-stack, backend-only, frontend-only). `default` uses the canonical Category+Item spec shared with app-demo; `full-stack` is the rich User/Project/Task demo.', "default")
    .option('--list', 'List available templates', false)
    .option('-s, --static', 'Pre-configure the project for the ReactAppStarter factory (fully standalone, no @specverse/runtime dependency in generated output). Matches `spv realize ... --static` — same semantic applied at init time.', false)
    .action(async (name: string,  options: CommandOptions) => {
      try {
        const __fn = fileURLToPath(import.meta.url);
        const __dn = dirname(__fn);

        // Resolve templates from package.json "specverse.templateDir" config
        const templatesDir = await (async () => {
          const { createRequire } = await import('module');
          const require = createRequire(import.meta.url);

          // Find our own package.json by walking up
          let dir = __dn;
          while (dir !== dirname(dir)) {
            const pkgPath = join(dir, 'package.json');
            if (existsSync(pkgPath)) {
              const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
              if (pkg.specverse?.templateDir) {
                const candidate = resolve(dir, pkg.specverse.templateDir);
                if (existsSync(candidate)) return candidate;
              }
            }
            dir = dirname(dir);
          }

          // Fallback: engine-realize assets
          try {
            const realizePkg = dirname(require.resolve('@specverse/engine-realize/package.json'));
            const candidate = join(realizePkg, 'assets', 'templates');
            if (existsSync(candidate)) return candidate;
          } catch { /* not installed */ }

          return null;
        })();

        if (!templatesDir) {
          console.error('Templates not found. Set "specverse.templateDir" in package.json or install @specverse/engine-realize.');
          process.exit(1);
        }

        if (options.list) {
          const templates = readdirSync(templatesDir).filter(
            d => statSync(join(templatesDir!, d)).isDirectory()
          );
          console.log('Available templates:');
          templates.forEach(t => console.log('  ' + t));
          return;
        }

        const projectName = name || 'my-project';
        // Commander applies the --template default ("full-stack"); the
        // fallback here only fires if a caller invoked the action handler
        // directly without going through commander.
        const templateName = options.template || 'full-stack';
        const templateDir = join(templatesDir, templateName);

        if (!existsSync(templateDir)) {
          console.error('Template not found: ' + templateName);
          console.error('Available: ' + readdirSync(templatesDir).filter(
            d => statSync(join(templatesDir!, d)).isDirectory()
          ).join(', '));
          process.exit(1);
        }

        const destDir = resolve((process.env.SPECVERSE_USER_CWD || process.cwd()), projectName);
        if (existsSync(destDir)) {
          console.error('Directory already exists: ' + destDir);
          process.exit(1);
        }

        // Copy template with variable substitution
        const kebab = projectName.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
        // PascalCase: split on hyphens / underscores / whitespace, capitalize each segment, join.
        // 'audit-backend-only' -> 'AuditBackendOnly', 'my_app' -> 'MyApp', 'foo' -> 'Foo'.
        // NOTE: regex char class is double-escaped because this whole handler
        // is embedded as a string in the generator template — \s here ends
        // up as s in the emitted source.
        const component = projectName
          .split(/[-_\s]+/)
          .filter(Boolean)
          .map((s: string) => s.charAt(0).toUpperCase() + s.slice(1))
          .join('');
        const vars: Record<string, string> = {
          '{{PROJECT_NAME}}': projectName,
          '{{projectName}}': projectName,
          '{{projectNameKebab}}': kebab,
          '{{componentName}}': component,
          '{{DB_USER}}': 'postgres',
          '{{DB_PASSWORD}}': 'postgres',
        };

        function copyDir(src: string, dest: string) {
          mkdirSync(dest, { recursive: true });
          for (const item of readdirSync(src)) {
            const srcPath = join(src, item);
            let destName = item;
            if (item === 'gitignore') destName = '.gitignore';
            if (item === 'dot.env.example') destName = '.env.example';
            const destPath = join(dest, destName);

            if (statSync(srcPath).isDirectory()) {
              copyDir(srcPath, destPath);
            } else {
              let content = readFileSync(srcPath, 'utf8');
              for (const [key, val] of Object.entries(vars)) {
                content = content.split(key).join(val);
              }
              writeFileSync(destPath, content);
            }
          }
        }

        copyDir(templateDir, destDir);

        // If the copied template didn't ship a specs/main.specly, load
        // the canonical default spec from @specverse/engines/assets —
        // same file app-demo's Server Manager "new spec" action uses,
        // so both entry points start a user on the same footing. The
        // template can opt out of this by shipping its own spec.
        const specDestPath = join(destDir, 'specs', 'main.specly');
        if (!existsSync(specDestPath)) {
          try {
            const { createRequire } = await import('module');
            const require = createRequire(import.meta.url);
            // Try @specverse/assets first (canonical home post 2026-04-25),
            // fall back to @specverse/engines for older installs.
            const candidates = [];
            try {
              const assetsPkg = require.resolve('@specverse/assets/package.json');
              candidates.push(
                join(dirname(assetsPkg), 'templates', 'default', 'specs', 'main.specly')
              );
            } catch {}
            try {
              const enginesPkg = require.resolve('@specverse/engines/package.json');
              candidates.push(
                join(dirname(enginesPkg), 'assets', 'templates', 'default', 'specs', 'main.specly')
              );
            } catch {}
            const canonicalSpec = candidates.find((p) => existsSync(p));
            if (canonicalSpec) {
              let content = readFileSync(canonicalSpec, 'utf8');
              for (const [key, val] of Object.entries(vars)) {
                content = content.split(key).join(val);
              }
              mkdirSync(join(destDir, 'specs'), { recursive: true });
              writeFileSync(specDestPath, content);
            }
          } catch { /* engines not installed or template missing — proceed */ }
        }

        // --static: flip any ReactAppRuntime mappings in the copied
        // manifests to ReactAppStarter so the user gets standalone-starter
        // output on first `spv realize` without having to re-pass the
        // flag. Same semantic as `spv realize --static` — just applied
        // at init time. Idempotent; no-op for templates without a frontend.
        if (options.static) {
          const manifestsDir = join(destDir, 'manifests');
          if (existsSync(manifestsDir)) {
            for (const f of readdirSync(manifestsDir)) {
              if (!f.endsWith('.yaml') && !f.endsWith('.yml')) continue;
              const p = join(manifestsDir, f);
              const before = readFileSync(p, 'utf8');
              const after = before.replace(
                /instanceFactory:\s*["']?ReactAppRuntime["']?/g,
                'instanceFactory: "ReactAppStarter"'
              );
              if (after !== before) writeFileSync(p, after, 'utf8');
            }
          }
        }

        console.log('Project created: ' + destDir);
        console.log('Template: ' + templateName + (options.static ? ' (static / ReactAppStarter)' : ''));
        console.log('');

        // Build the "Next steps" hint from the actual scripts the
        // chosen template ships, so we never tell the user to run a
        // command that doesn't exist in their package.json.
        const destPkgPath = join(destDir, 'package.json');
        const destPkg = existsSync(destPkgPath)
          ? JSON.parse(readFileSync(destPkgPath, 'utf8'))
          : { scripts: {} };
        const scripts = destPkg.scripts || {};
        console.log('Next steps:');
        console.log('  cd ' + projectName);
        if (scripts.setup) {
          console.log('  npm run setup          # validate, generate code, install deps, setup db');
        }
        if (scripts['dev:backend'] && scripts['dev:frontend']) {
          console.log('  npm run dev:backend    # start backend (terminal 1)');
          console.log('  npm run dev:frontend   # start frontend (terminal 2)');
        } else if (scripts.dev) {
          console.log('  npm run dev            # start dev server');
        }
        if (scripts['test:e2e']) {
          console.log('  npm run test:e2e       # run end-to-end tests (after starting dev servers)');
        }
      } catch (error: any) {
        console.error('Error:', error.message);
        process.exit(1);
      }
    });
}