#!/usr/bin/env node

const fs = require('fs');
const path = require('path');
const { spawnSync } = require('child_process');

const rootDir = path.join(__dirname, '..');
const buildDir = path.join(rootDir, 'build');
const distDir = path.join(rootDir, 'dist');
const bundleDir = path.join(buildDir, 'ncc');
const pkgProjectDir = path.join(buildDir, 'pkg');
const deployDir = path.join(rootDir, 'deploy');
const deploymentDocName = '\u751f\u4ea7\u5b9e\u65bd\u90e8\u7f72\u6587\u6863.md';
const runtimeAssets = [
  'config.json',
  'alModel.json',
  deploymentDocName,
];
const targets = {
  'win-x64': {
    pkgTarget: 'node18-win-x64',
    outputName: 'jhm-service.exe',
    deploySourceDir: path.join(deployDir, 'windows'),
    executableMode: null,
  },
  'linux-x64': {
    pkgTarget: 'node18-linux-x64',
    outputName: 'jhm-service',
    deploySourceDir: path.join(deployDir, 'linux'),
    executableMode: 0o755,
  },
};

function parseArgs(argv) {
  const selectedTargets = new Set(Object.keys(targets));

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

    if (arg === '--target' && value) {
      selectedTargets.clear();

      for (const item of value.split(',').map((entry) => entry.trim()).filter(Boolean)) {
        if (!targets[item]) {
          throw new Error(`Unsupported build target: ${item}`);
        }

        selectedTargets.add(item);
      }

      index += 1;
    }
  }

  return Array.from(selectedTargets);
}

function runNode(scriptPath, args) {
  console.log(`[BUILD] node ${path.relative(rootDir, scriptPath)} ${args.join(' ')}`);

  const result = spawnSync(process.execPath, [scriptPath, ...args], {
    cwd: rootDir,
    stdio: 'inherit',
  });

  if (result.status !== 0) {
    throw new Error(`Command failed: node ${scriptPath} ${args.join(' ')}`);
  }
}

function ensureCleanWorkspace() {
  fs.rmSync(buildDir, { recursive: true, force: true });
  fs.rmSync(distDir, { recursive: true, force: true });
  fs.mkdirSync(buildDir, { recursive: true });
  fs.mkdirSync(distDir, { recursive: true });
}

function buildBundle() {
  const nccCli = require.resolve('@vercel/ncc/dist/ncc/cli');
  runNode(nccCli, ['build', 'app.js', '-o', bundleDir, '--target', 'es2019']);
}

function preparePkgProject() {
  const pkgBundleDir = path.join(pkgProjectDir, 'bundle');
  const pkgEntryPath = path.join(pkgProjectDir, 'entry.js');
  const pkgConfigPath = path.join(pkgProjectDir, 'package.json');
  const bundleSourcePath = path.join(bundleDir, 'index.js');
  const bundleTargetPath = path.join(pkgBundleDir, 'index.cjs');
  const bootstrapSource = `#!/usr/bin/env node

const fs = require('fs');
const path = require('path');
const Module = require('module');

const bundlePath = path.join(__dirname, 'bundle', 'index.cjs');
const source = fs.readFileSync(bundlePath, 'utf8');
const bundledModule = new Module(bundlePath);

bundledModule.filename = bundlePath;
bundledModule.id = '.';
bundledModule.paths = Module._nodeModulePaths(path.dirname(bundlePath));
Module._cache[bundlePath] = bundledModule;
process.mainModule = bundledModule;
require.main = bundledModule;

bundledModule._compile(source, bundlePath);
`;
  const pkgConfig = {
    name: 'jhm-pkg-bootstrap',
    version: '1.0.0',
    private: true,
    type: 'commonjs',
    bin: 'entry.js',
    pkg: {
      assets: [
        'bundle/index.cjs',
      ],
    },
  };

  fs.mkdirSync(pkgBundleDir, { recursive: true });
  fs.copyFileSync(bundleSourcePath, bundleTargetPath);
  fs.writeFileSync(pkgEntryPath, bootstrapSource, 'utf8');
  fs.writeFileSync(pkgConfigPath, `${JSON.stringify(pkgConfig, null, 2)}\n`, 'utf8');
}

function buildExecutable(targetKey, targetConfig) {
  const pkgCli = require.resolve('pkg/lib-es5/bin.js');
  const targetDir = path.join(distDir, targetKey);
  const outputPath = path.join(targetDir, targetConfig.outputName);

  fs.mkdirSync(targetDir, { recursive: true });

  runNode(pkgCli, [
    pkgProjectDir,
    '--targets',
    targetConfig.pkgTarget,
    '--output',
    outputPath,
    '--public',
    '--public-packages',
    '*',
    '--no-bytecode',
  ]);

  if (!fs.existsSync(outputPath)) {
    throw new Error(`Expected executable was not created: ${outputPath}`);
  }

  if (targetConfig.executableMode) {
    fs.chmodSync(outputPath, targetConfig.executableMode);
  }
}

function copyRuntimeAssets(targetDir) {
  const runtimeDir = path.join(targetDir, 'runtime');
  const logsDir = path.join(targetDir, 'logs');

  fs.mkdirSync(runtimeDir, { recursive: true });
  fs.mkdirSync(logsDir, { recursive: true });

  for (const assetName of runtimeAssets) {
    const sourcePath = path.join(rootDir, assetName);

    if (!fs.existsSync(sourcePath)) {
      console.warn(`[BUILD] Skip missing asset: ${assetName}`);
      continue;
    }

    fs.copyFileSync(sourcePath, path.join(runtimeDir, assetName));
  }
}

function copyDeploymentTemplates(targetKey, targetConfig) {
  const sourceDir = targetConfig.deploySourceDir;

  if (!fs.existsSync(sourceDir)) {
    return;
  }

  const targetDir = path.join(distDir, targetKey, 'service');
  fs.mkdirSync(targetDir, { recursive: true });
  fs.cpSync(sourceDir, targetDir, { recursive: true });

  for (const entry of fs.readdirSync(targetDir)) {
    const fullPath = path.join(targetDir, entry);
    const extension = path.extname(entry);

    if (extension === '.sh') {
      fs.chmodSync(fullPath, 0o755);
    }
  }
}

function copySharedDocs(selectedTargets) {
  const sourcePath = path.join(rootDir, deploymentDocName);

  if (!fs.existsSync(sourcePath)) {
    return;
  }

  fs.copyFileSync(sourcePath, path.join(distDir, deploymentDocName));

  for (const targetKey of selectedTargets) {
    fs.copyFileSync(sourcePath, path.join(distDir, targetKey, deploymentDocName));
  }
}

function main() {
  const selectedTargets = parseArgs(process.argv);
  ensureCleanWorkspace();
  buildBundle();
  preparePkgProject();

  for (const targetKey of selectedTargets) {
    console.log(`[BUILD] Packaging target: ${targetKey}`);
    buildExecutable(targetKey, targets[targetKey]);
    copyRuntimeAssets(path.join(distDir, targetKey));
    copyDeploymentTemplates(targetKey, targets[targetKey]);
  }

  copySharedDocs(selectedTargets);

  console.log('[BUILD] Build completed.');
  for (const targetKey of selectedTargets) {
    console.log(`[BUILD] Output: dist/${targetKey}`);
  }
}

main();