#!/usr/bin/env node

/**
 * Release Builder Agent — SF-07
 *
 * 将 SF-06 Electron Project 封装为可发布软件包结构。
 *
 * 职责：Electron Project → Release Package Structure
 * 不做：自动更新、CI/CD、Docker、云发布、安装器、签名、证书
 *
 * Usage:
 *   node scripts/release-builder-agent.mjs --input <electron-dir> [options]
 *
 * @module release-builder-agent
 */

import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from "node:fs";
import { resolve, dirname, join } from "node:path";
import { fileURLToPath } from "node:url";
import { createHash } from "node:crypto";

const __dirname = dirname(resolve(fileURLToPath(import.meta.url)));
const WORKSPACE = resolve(__dirname, "..");

const GENERATOR_VERSION = "1.0.0";
const PLATFORMS = ["windows", "macos", "linux"];

// ═══════════════════════════════════════════════════════
// 1. Metadata Extraction
// ═══════════════════════════════════════════════════════



function extractMetadataSync(projectDir) {
  const meta = {
    projectName: "app",
    version: "1.0.0",
    buildNumber: 1,
    domain: "unknown",
    entities: [],
    routes: [],
    screens: [],
  };

  // Read root package.json
  const rootPkgPath = join(projectDir, "package.json");
  if (existsSync(rootPkgPath)) {
    try {
      const pkg = JSON.parse(readFileSync(rootPkgPath, "utf8"));
      meta.projectName = pkg.name || meta.projectName;
      meta.version = pkg.version || meta.version;
    } catch {}
  }

  // Read desktop package.json
  const desktopPkgPath = join(projectDir, "apps", "desktop", "package.json");
  if (existsSync(desktopPkgPath)) {
    try {
      const pkg = JSON.parse(readFileSync(desktopPkgPath, "utf8"));
      if (pkg.name) meta.projectName = pkg.name.replace(/-desktop$/, "");
      if (pkg.version) meta.version = pkg.version;
    } catch {}
  }

  // Read PRD if exists
  const prdPath = join(projectDir, "prd.json");
  if (existsSync(prdPath)) {
    try {
      const prd = JSON.parse(readFileSync(prdPath, "utf8"));
      if (prd.projectName) meta.projectName = prd.projectName;
      if (prd.domain) meta.domain = prd.domain;
      if (prd.features) meta.entities = prd.features.map(f => f.name || f);
      if (prd.apiRequirements) meta.routes = prd.apiRequirements.map(r => `${r.method} ${r.path}`);
      if (prd.pages) meta.screens = prd.pages.map(p => p.name || p);
    } catch {}
  }

  // Scan for entities in backend routes
  const routesDir = join(projectDir, "apps", "api", "src", "routes");
  if (existsSync(routesDir)) {
    try {
      const files = readdirSync(routesDir).filter(f => f.endsWith(".ts") || f.endsWith(".js"));
      if (meta.entities.length === 0) {
        meta.entities = files.map(f => f.replace(/\.(ts|js)$/, "").replace(/-route$/, "").replace(/\.route$/, ""));
      }
    } catch {}
  }

  // Scan for screens in frontend
  const appDir = join(projectDir, "apps", "web", "app");
  if (existsSync(appDir)) {
    try {
      const entries = readdirSync(appDir, { withFileTypes: true });
      if (meta.screens.length === 0) {
        meta.screens = entries
          .filter(e => e.isDirectory() && !e.name.startsWith("_") && !e.name.startsWith("."))
          .map(e => e.name);
      }
    } catch {}
  }

  // Count API routes from index.ts
  const apiSrcDir = join(projectDir, "apps", "api", "src");
  if (existsSync(apiSrcDir) && meta.routes.length === 0) {
    try {
      const indexContent = readFileSync(join(apiSrcDir, "index.ts"), "utf8");
      const routeMatches = indexContent.match(/app\.(use|get|post|put|patch|delete)\s*\(\s*["']([^"']+)/g);
      if (routeMatches) meta.routes = routeMatches;
    } catch {}
  }

  return meta;
}

// ═══════════════════════════════════════════════════════
// 2. Version Generator
// ═══════════════════════════════════════════════════════

function generateVersion(meta) {
  return JSON.stringify({
    name: meta.projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-"),
    version: meta.version,
    buildNumber: meta.buildNumber,
    platforms: [...PLATFORMS],
  }, null, 2);
}

// ═══════════════════════════════════════════════════════
// 3. Release Manifest
// ═══════════════════════════════════════════════════════

function generateManifest(meta, artifacts) {
  const files = [];
  for (const art of artifacts) {
    files.push({
      path: art.path,
      size: art.size,
      sha256: art.sha256,
    });
  }

  return JSON.stringify({
    project: meta.projectName,
    version: meta.version,
    buildNumber: meta.buildNumber,
    generatedAt: new Date().toISOString(),
    generator: "release-builder-agent",
    generatorVersion: GENERATOR_VERSION,
    platforms: [...PLATFORMS],
    files,
    totalFiles: files.length,
    totalSize: files.reduce((s, f) => s + f.size, 0),
  }, null, 2);
}

// ═══════════════════════════════════════════════════════
// 4. Checksum Generator
// ═══════════════════════════════════════════════════════

function sha256(content) {
  return createHash("sha256").update(typeof content === "string" ? content : content).digest("hex");
}

function generateChecksums(artifacts) {
  return artifacts.map(a => `${a.sha256}  ${a.path}`).join("\n") + "\n";
}

// ═══════════════════════════════════════════════════════
// 5. Release Notes
// ═══════════════════════════════════════════════════════

function generateReleaseNotes(meta) {
  const now = new Date();
  const dateStr = now.toISOString().split("T")[0];
  const timeStr = now.toISOString().split("T")[1].split(".")[0];

  const lines = [];
  const h = (t) => { lines.push(t); return lines; };

  h(`# ${meta.projectName} v${meta.version}`);
  h(``);
  h(`> Release Builder Agent — SF-07`);
  h(`> Generated: ${dateStr} ${timeStr} UTC`);
  h(``);

  h(`## Version`);
  h(``);
  h(`- **Name:** ${meta.projectName}`);
  h(`- **Version:** ${meta.version}`);
  h(`- **Build:** #${meta.buildNumber}`);
  h(``);

  h(`## Features`);
  h(``);
  if (meta.entities.length > 0) {
    for (const e of meta.entities) {
      h(`- ${e}`);
    }
  } else {
    h(`- (No features detected)`);
  }
  h(``);

  h(`## Build Info`);
  h(``);
  h(`- **Build Time:** ${now.toISOString()}`);
  h(`- **Generator:** release-builder-agent v${GENERATOR_VERSION}`);
  h(`- **Node Version:** ${process.version}`);
  h(``);

  h(`## Platforms`);
  h(``);
  for (const p of PLATFORMS) {
    h(`- ✅ ${p}`);
  }
  h(``);

  h(`## Installation`);
  h(``);
  h(`### Windows`);
  h(`\`\`\``);
  h(`Download the .exe installer from release/windows/`);
  h(`\`\`\``);
  h(``);
  h(`### macOS`);
  h(`\`\`\``);
  h(`Download the .dmg from release/macos/`);
  h(`\`\`\``);
  h(``);
  h(`### Linux`);
  h(`\`\`\``);
  h(`Download the .AppImage from release/linux/`);
  h(`\`\`\``);
  h(``);

  h(`## Checksums`);
  h(``);
  h(`See \`checksums/checksums.txt\` for SHA256 verification.`);
  h(``);

  h(`---`);
  h(`*Generated by Release Builder Agent — SF-07*`);

  return lines.join("\n");
}

// ═══════════════════════════════════════════════════════
// 6. Build Metadata
// ═══════════════════════════════════════════════════════

function generateBuildInfo(meta) {
  return JSON.stringify({
    nodeVersion: process.version,
    generatorVersion: GENERATOR_VERSION,
    buildTime: new Date().toISOString(),
    domain: meta.domain,
    entityCount: meta.entities.length,
    routeCount: meta.routes.length,
    screenCount: meta.screens.length,
    platforms: [...PLATFORMS],
    project: meta.projectName,
    version: meta.version,
  }, null, 2);
}

// ═══════════════════════════════════════════════════════
// 7. Platform Artifact Layout
// ═══════════════════════════════════════════════════════

function generatePlatformArtifacts(meta) {
  const safeName = meta.projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
  const artifacts = {};

  // Windows
  artifacts[`windows/${safeName}-setup-${meta.version}.exe`] =
    `[PLACEHOLDER] ${meta.projectName} v${meta.version} Windows Installer\n` +
    `This is a placeholder file for the Windows NSIS installer.\n` +
    `Generated: ${new Date().toISOString()}\n`;
  artifacts[`windows/${safeName}-${meta.version}-portable.exe`] =
    `[PLACEHOLDER] ${meta.projectName} v${meta.version} Windows Portable\n` +
    `This is a placeholder file for the Windows portable executable.\n` +
    `Generated: ${new Date().toISOString()}\n`;

  // macOS
  artifacts[`macos/${safeName}-${meta.version}.dmg`] =
    `[PLACEHOLDER] ${meta.projectName} v${meta.version} macOS Disk Image\n` +
    `This is a placeholder file for the macOS DMG installer.\n` +
    `Generated: ${new Date().toISOString()}\n`;
  artifacts[`macos/${safeName}-${meta.version}-arm64.dmg`] =
    `[PLACEHOLDER] ${meta.projectName} v${meta.version} macOS ARM64 Disk Image\n` +
    `This is a placeholder file for the macOS ARM64 DMG.\n` +
    `Generated: ${new Date().toISOString()}\n`;

  // Linux
  artifacts[`linux/${safeName}-${meta.version}.AppImage`] =
    `[PLACEHOLDER] ${meta.projectName} v${meta.version} Linux AppImage\n` +
    `This is a placeholder file for the Linux AppImage.\n` +
    `Generated: ${new Date().toISOString()}\n`;
  artifacts[`linux/${safeName}_${meta.version}_amd64.deb`] =
    `[PLACEHOLDER] ${meta.projectName} v${meta.version} Linux Debian Package\n` +
    `This is a placeholder file for the Linux .deb package.\n` +
    `Generated: ${new Date().toISOString()}\n`;

  return artifacts;
}

// ═══════════════════════════════════════════════════════
// 8. Main Build Function
// ═══════════════════════════════════════════════════════

/**
 * Build release package structure for an Electron project.
 *
 * @param {object} options
 * @param {string} options.projectDir — Electron project root (with apps/web, apps/api, apps/desktop)
 * @param {string} [options.projectName] — Override project name
 * @param {string} [options.version] — Override version
 * @param {number} [options.buildNumber] — Override build number
 * @returns {object} { files, stats, error, message }
 */
export function buildRelease(options = {}) {
  const {
    projectDir = null,
    projectName = null,
    version = null,
    buildNumber = 1,
  } = options;

  // Extract metadata from project
  const meta = projectDir ? extractMetadataSync(projectDir) : {
    projectName: "app",
    version: "1.0.0",
    buildNumber: 1,
    domain: "unknown",
    entities: [],
    routes: [],
    screens: [],
  };

  // Apply overrides
  if (projectName) meta.projectName = projectName;
  if (version) meta.version = version;
  meta.buildNumber = buildNumber;

  const files = {};

  // Generate platform artifacts (placeholders)
  const platformArtifacts = generatePlatformArtifacts(meta);

  // Add platform artifacts to files
  for (const [path, content] of Object.entries(platformArtifacts)) {
    files[`release/${path}`] = content;
  }

  // Compute artifact metadata for manifest
  const artifactMeta = Object.entries(platformArtifacts).map(([path, content]) => ({
    path,
    size: Buffer.byteLength(content, "utf8"),
    sha256: sha256(content),
  }));

  // Generate version.json
  files["release/version.json"] = generateVersion(meta);

  // Generate manifest.json
  files["release/manifests/manifest.json"] = generateManifest(meta, artifactMeta);

  // Generate checksums.txt
  files["release/checksums/checksums.txt"] = generateChecksums(artifactMeta);

  // Generate release-notes.md
  files["release/release-notes/release-notes.md"] = generateReleaseNotes(meta);

  // Generate build-info.json
  files["release/build-info.json"] = generateBuildInfo(meta);

  // Generate README
  files["release/README.md"] = generateReadme(meta);

  // Stats
  const allPaths = Object.keys(files);
  const stats = {
    totalFiles: allPaths.length,
    platformFiles: allPaths.filter(p => p.startsWith("release/windows/") || p.startsWith("release/macos/") || p.startsWith("release/linux/")).length,
    manifestFiles: allPaths.filter(p => p.includes("manifest")).length,
    checksumFiles: allPaths.filter(p => p.includes("checksum")).length,
    releaseNotesFiles: allPaths.filter(p => p.includes("release-notes")).length,
    metadataFiles: allPaths.filter(p => p.endsWith(".json")).length,
    totalSize: Object.values(files).reduce((s, c) => s + Buffer.byteLength(c, "utf8"), 0),
  };

  return { files, stats, meta, error: null, message: null };
}

// ═══════════════════════════════════════════════════════
// 9. README Generator
// ═══════════════════════════════════════════════════════

function generateReadme(meta) {
  const lines = [];
  const h = (t) => { lines.push(t); return lines; };

  h(`# ${meta.projectName} — Release Package`);
  h(``);
  h(`> Version: ${meta.version} | Build: #${meta.buildNumber}`);
  h(`> Generated: ${new Date().toISOString()}`);
  h(``);

  h(`## Directory Structure`);
  h(``);
  h(`\`\`\``);
  h(`release/`);
  h(`├── version.json          — Version metadata`);
  h(`├── build-info.json       — Build environment info`);
  h(`├── README.md             — This file`);
  h(`├── manifests/`);
  h(`│   └── manifest.json     — Release manifest with file hashes`);
  h(`├── checksums/`);
  h(`│   └── checksums.txt     — SHA256 checksums for verification`);
  h(`├── release-notes/`);
  h(`│   └── release-notes.md  — Human-readable release notes`);
  h(`├── windows/              — Windows installers`);
  h(`├── macos/                — macOS disk images`);
  h(`└── linux/                — Linux packages`);
  h(`\`\`\``);
  h(``);

  h(`## Verification`);
  h(``);
  h(`\`\`\`bash`);
  h(`# Verify checksums`);
  h(`cd release/checksums`);
  h(`shasum -a 256 -c checksums.txt`);
  h(`\`\`\``);
  h(``);

  h(`---`);
  h(`*Generated by Release Builder Agent — SF-07*`);

  return lines.join("\n");
}

// ═══════════════════════════════════════════════════════
// 10. File I/O
// ═══════════════════════════════════════════════════════

export function writeRelease(result, outputDir) {
  mkdirSync(outputDir, { recursive: true });
  for (const [relPath, content] of Object.entries(result.files)) {
    const fullPath = resolve(outputDir, relPath);
    mkdirSync(dirname(fullPath), { recursive: true });
    writeFileSync(fullPath, content, "utf-8");
  }
}

// ═══════════════════════════════════════════════════════
// 11. CLI Entry
// ═══════════════════════════════════════════════════════

function parseArgs() {
  const args = process.argv.slice(2);
  const opts = {
    input: null,
    output: null,
    projectName: null,
    version: null,
    buildNumber: 1,
    verbose: false,
    help: false,
  };
  for (let i = 0; i < args.length; i++) {
    if (args[i] === "--input" && args[i + 1]) opts.input = args[++i];
    else if (args[i] === "--output" && args[i + 1]) opts.output = args[++i];
    else if (args[i] === "--name" && args[i + 1]) opts.projectName = args[++i];
    else if (args[i] === "--version" && args[i + 1]) opts.version = args[++i];
    else if (args[i] === "--build-number" && args[i + 1]) opts.buildNumber = parseInt(args[++i], 10);
    else if (args[i] === "--verbose") opts.verbose = true;
    else if (args[i] === "--help" || args[i] === "-h") opts.help = true;
  }
  return opts;
}

async function main() {
  const opts = parseArgs();

  if (opts.help) {
    console.log(
      "\nRelease Builder Agent — SF-07\n\n" +
      "Generate release package structure for an Electron project.\n\n" +
      "Usage:\n" +
      "  node scripts/release-builder-agent.mjs --input <electron-dir> [options]\n\n" +
      "Options:\n" +
      "  --input <dir>         Project directory (with apps/web, apps/api, apps/desktop)\n" +
      "  --output <dir>        Output directory (default: <input>/release)\n" +
      "  --name <name>         Override project name\n" +
      "  --version <ver>       Override version\n" +
      "  --build-number <n>    Build number (default: 1)\n" +
      "  --verbose             Verbose output\n" +
      "  --help                Show this help\n"
    );
    return;
  }

  const result = buildRelease({
    projectDir: opts.input,
    projectName: opts.projectName,
    version: opts.version,
    buildNumber: opts.buildNumber,
  });

  if (result.error) {
    console.error(result.message);
    process.exit(1);
  }

  const outputDir = opts.output
    ? resolve(opts.output)
    : opts.input
    ? resolve(opts.input, "release")
    : resolve(WORKSPACE, "release");

  writeRelease(result, outputDir);

  if (opts.verbose) {
    console.error("Project: " + result.meta.projectName);
    console.error("Version: " + result.meta.version);
    console.error("Files: " + result.stats.totalFiles);
    console.error("Platform files: " + result.stats.platformFiles);
    console.error("Total size: " + result.stats.totalSize + " bytes");
  }

  console.log(JSON.stringify({
    projectName: result.meta.projectName,
    version: result.meta.version,
    outputDir,
    stats: result.stats,
  }, null, 2));
}

if (process.argv[1] && (import.meta.url === "file://" + process.argv[1] || import.meta.url.endsWith(process.argv[1]))) {
  main();
}