#!/usr/bin/env node

import fs from 'node:fs';
import path from 'node:path';
import { fileURLToPath } from 'node:url';

const TEMPLATE_ROOT = path.resolve(
  path.dirname(fileURLToPath(import.meta.url)),
  '..',
  'templates',
  'discord-oauth-vue3-vite',
  'src',
  'server',
  'discord-oauth',
);

function usage() {
  console.error(`Usage: node resources/scripts/scaffold-discord-oauth-vue3-vite.mjs [options]

Required:
  --project-root <path>            Target project path.

Optional:
  --mode <dry-run|apply>           Default: dry-run
  --frontend-origin <url>          Default: http://localhost:5173
  --allowlist-discord-ids <csv>    Default: empty
  --scopes <csv>                   Default: identify,email
  --force                          Overwrite generated files.
  --help                           Show this help text.
`);
}

function parseArgs(argv) {
  const options = {
    mode: 'dry-run',
    frontendOrigin: 'http://localhost:5173',
    allowlistDiscordIds: '',
    scopes: 'identify,email',
    force: false,
  };

  for (let index = 0; index < argv.length; index += 1) {
    const arg = argv[index];

    if (arg === '--help') {
      usage();
      process.exit(0);
    }

    if (arg === '--project-root') {
      options.projectRoot = argv[index + 1];
      index += 1;
      continue;
    }

    if (arg === '--mode') {
      options.mode = argv[index + 1];
      index += 1;
      continue;
    }

    if (arg === '--frontend-origin') {
      options.frontendOrigin = argv[index + 1];
      index += 1;
      continue;
    }

    if (arg === '--allowlist-discord-ids') {
      options.allowlistDiscordIds = argv[index + 1];
      index += 1;
      continue;
    }

    if (arg === '--scopes') {
      options.scopes = argv[index + 1];
      index += 1;
      continue;
    }

    if (arg === '--force') {
      options.force = true;
      continue;
    }

    throw new Error(`Unknown argument: ${arg}`);
  }

  if (!options.projectRoot) {
    throw new Error('--project-root is required.');
  }

  if (!['dry-run', 'apply'].includes(options.mode)) {
    throw new Error('--mode must be dry-run or apply.');
  }

  options.projectRoot = path.resolve(options.projectRoot);
  options.targetRoot = path.join(options.projectRoot, 'src', 'server', 'discord-oauth');
  options.allowlistDiscordIdsJson = JSON.stringify(
    options.allowlistDiscordIds
      .split(',')
      .map((entry) => entry.trim())
      .filter(Boolean),
  );
  options.scopesJson = JSON.stringify(
    options.scopes
      .split(',')
      .map((entry) => entry.trim())
      .filter(Boolean),
  );
  return options;
}

function ensureDir(dirPath, mode) {
  if (mode === 'dry-run') {
    return;
  }
  fs.mkdirSync(dirPath, { recursive: true });
}

function isTextFile(filePath) {
  return /\.(?:js|json|md|txt|mjs|sh)$/.test(filePath);
}

function replacePlaceholders(content, options) {
  return content
    .replaceAll('__FRONTEND_ORIGIN__', options.frontendOrigin)
    .replaceAll('__ALLOWLIST_DISCORD_IDS_JSON__', options.allowlistDiscordIdsJson)
    .replaceAll('__SCOPES_JSON__', options.scopesJson);
}

function walkFiles(rootDir, callback) {
  const entries = fs.readdirSync(rootDir, { withFileTypes: true });

  for (const entry of entries) {
    const fullPath = path.join(rootDir, entry.name);
    if (entry.isDirectory()) {
      walkFiles(fullPath, callback);
      continue;
    }

    callback(fullPath);
  }
}

function scaffold(options) {
  if (!fs.existsSync(TEMPLATE_ROOT)) {
    throw new Error(`Template root not found: ${TEMPLATE_ROOT}`);
  }

  const results = [];
  walkFiles(TEMPLATE_ROOT, (sourcePath) => {
    const relativePath = path.relative(TEMPLATE_ROOT, sourcePath);
    const targetPath = path.join(options.targetRoot, relativePath);
    const exists = fs.existsSync(targetPath);

    if (exists && !options.force) {
      results.push({ action: 'skipped', filePath: targetPath });
      return;
    }

    const action = exists ? 'updated' : 'created';
    if (options.mode === 'apply') {
      ensureDir(path.dirname(targetPath), options.mode);
      const rawContent = fs.readFileSync(sourcePath);
      const content = isTextFile(sourcePath)
        ? replacePlaceholders(rawContent.toString('utf8'), options)
        : rawContent;
      fs.writeFileSync(targetPath, content);
    }

    results.push({ action, filePath: targetPath });
  });

  return results;
}

function main() {
  const options = parseArgs(process.argv.slice(2));

  console.log(`Target bundle: ${path.relative(options.projectRoot, options.targetRoot)}`);
  console.log(`Mode: ${options.mode}`);

  const results = scaffold(options);
  for (const result of results) {
    console.log(`${result.action.toUpperCase()}: ${path.relative(options.projectRoot, result.filePath)}`);
  }

  if (options.mode === 'dry-run') {
    console.log('Dry-run only. Re-run with --mode apply to write files.');
  }
}

main();