#!/usr/bin/env node

import {
  lstat,
  mkdir,
  open,
  readFile,
  rmdir,
  unlink,
} from "node:fs/promises";
import path from "node:path";
import { fileURLToPath, pathToFileURL } from "node:url";

const skillDirectory = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
const templateDirectory = path.join(skillDirectory, "assets", "templates");
const fileOperations = { mkdir, open, rmdir, unlink };

const commonTargets = [
  ["package.json", "common/package.json"],
  ["package-lock.json", "common/package-lock.json"],
  ["vite.config.js", "common/vite.config.js"],
];

const targetsByProjectType = {
  interactive_ai_app: [
    ...commonTargets,
    ["index.html", "interactive_ai_app/index.html"],
    ["src/main.js", "interactive_ai_app/main.js"],
    ["src/style.css", "interactive_ai_app/style.css"],
  ],
};

const canonicalProjectTypes = {
  interactive_ai_app: "interactive_ai_app",
  mini_game: "interactive_ai_app",
  mini_program: "interactive_ai_app",
};

class ScaffoldError extends Error {
  constructor(code, message, details = {}) {
    super(message);
    this.code = code;
    this.details = details;
  }
}

function parseArguments(argv) {
  if (argv.length !== 2 || argv[0] !== "--project-root" || !argv[1]?.trim()) {
    throw new ScaffoldError(
      "USAGE_INVALID",
      "脚本参数无效，必须提供 --project-root <project-directory>。",
    );
  }

  return path.resolve(argv[1]);
}

async function readProjectType(projectRoot) {
  const configPath = path.join(projectRoot, ".makelore", "project.json");
  let source;

  try {
    source = await readFile(configPath, "utf8");
  } catch (error) {
    if (error?.code === "ENOENT") {
      throw new ScaffoldError(
        "PROJECT_CONFIG_MISSING",
        "当前目录缺少 .makelore/project.json。",
      );
    }
    throw new ScaffoldError(
      "PROJECT_CONFIG_INVALID",
      "无法读取 .makelore/project.json。",
    );
  }

  let config;
  try {
    config = JSON.parse(source);
  } catch {
    throw new ScaffoldError(
      "PROJECT_CONFIG_INVALID",
      ".makelore/project.json 不是有效 JSON。",
    );
  }

  if (!config || typeof config !== "object" || config.schemaVersion !== 2) {
    throw new ScaffoldError(
      "PROJECT_CONFIG_INVALID",
      ".makelore/project.json 必须使用 schemaVersion 2。",
    );
  }

  const projectType = typeof config.projectType === "string"
    ? canonicalProjectTypes[config.projectType]
    : undefined;
  if (!projectType || !Object.hasOwn(targetsByProjectType, projectType)) {
    throw new ScaffoldError(
      "PROJECT_TYPE_UNSUPPORTED",
      "仅支持初始化 interactive_ai_app 项目。",
    );
  }

  return projectType;
}

function toNativePath(root, relativePath) {
  return path.join(root, ...relativePath.split("/"));
}

async function readTemplates(targets) {
  const loaded = [];
  const missing = [];

  for (const [targetPath, templatePath] of targets) {
    try {
      loaded.push({
        targetPath,
        contents: await readFile(toNativePath(templateDirectory, templatePath)),
      });
    } catch {
      missing.push(targetPath);
    }
  }

  if (missing.length > 0) {
    throw new ScaffoldError(
      "TEMPLATE_UNAVAILABLE",
      "插件缺少必需的工程模板，请重新安装。",
      { paths: missing.sort() },
    );
  }

  return loaded;
}

async function pathState(candidate) {
  try {
    return await lstat(candidate);
  } catch (error) {
    if (error?.code === "ENOENT") {
      return undefined;
    }
    throw error;
  }
}

function parentDirectories(relativePath) {
  const parents = [];
  let current = path.posix.dirname(relativePath);

  while (current !== ".") {
    parents.push(current);
    current = path.posix.dirname(current);
  }

  return parents.reverse();
}

async function preflightTargets(projectRoot, templates) {
  const conflicts = new Set();
  const missingDirectories = new Set();

  for (const { targetPath } of templates) {
    let blockedByParent = false;
    for (const directory of parentDirectories(targetPath)) {
      const state = await pathState(toNativePath(projectRoot, directory));
      if (!state) {
        missingDirectories.add(directory);
      } else if (!state.isDirectory()) {
        conflicts.add(directory);
        blockedByParent = true;
        break;
      }
    }

    if (!blockedByParent && await pathState(toNativePath(projectRoot, targetPath))) {
      conflicts.add(targetPath);
    }
  }

  if (conflicts.size > 0) {
    throw new ScaffoldError(
      "TARGET_CONFLICT",
      "目标路径已存在或必需的父路径不是目录，未写入任何文件。",
      { paths: [...conflicts].sort() },
    );
  }

  return [...missingDirectories].sort((left, right) => {
    const depthDifference = left.split("/").length - right.split("/").length;
    return depthDifference || left.localeCompare(right);
  });
}

function relativeProjectPath(projectRoot, absolutePath) {
  const relativePath = path.relative(projectRoot, absolutePath);
  return path.sep === "/" ? relativePath : relativePath.split(path.sep).join("/");
}

async function rollback(projectRoot, createdFiles, createdDirectories, operations) {
  const remainingPaths = [];
  for (const filePath of [...createdFiles].reverse()) {
    try {
      await operations.unlink(filePath);
    } catch {
      remainingPaths.push(relativeProjectPath(projectRoot, filePath));
    }
  }

  for (const directoryPath of [...createdDirectories].reverse()) {
    try {
      await operations.rmdir(directoryPath);
    } catch {
      remainingPaths.push(relativeProjectPath(projectRoot, directoryPath));
    }
  }

  return [...new Set(remainingPaths)].sort();
}

export async function writeScaffold(
  projectRoot,
  templates,
  missingDirectories,
  operations = fileOperations,
) {
  const createdFiles = [];
  const createdDirectories = [];

  try {
    for (const relativeDirectory of missingDirectories) {
      const absoluteDirectory = toNativePath(projectRoot, relativeDirectory);
      await operations.mkdir(absoluteDirectory);
      createdDirectories.push(absoluteDirectory);
    }

    for (const { targetPath, contents } of templates) {
      const absoluteTarget = toNativePath(projectRoot, targetPath);
      let handle;
      try {
        handle = await operations.open(absoluteTarget, "wx");
        createdFiles.push(absoluteTarget);
        await handle.writeFile(contents);
      } finally {
        await handle?.close();
      }
    }
  } catch {
    const remainingPaths = await rollback(
      projectRoot,
      createdFiles,
      createdDirectories,
      operations,
    );
    throw new ScaffoldError(
      "WRITE_FAILED",
      "创建工程骨架失败；本次新建内容已尽力回滚。",
      remainingPaths.length > 0 ? { paths: remainingPaths } : {},
    );
  }
}

async function scaffold(argv) {
  const projectRoot = parseArguments(argv);
  const projectType = await readProjectType(projectRoot);
  const templates = await readTemplates(targetsByProjectType[projectType]);
  const missingDirectories = await preflightTargets(projectRoot, templates);
  await writeScaffold(projectRoot, templates, missingDirectories);

  return {
    schemaVersion: 1,
    ok: true,
    status: "created",
    projectType,
    createdFiles: templates.map(({ targetPath }) => targetPath).sort(),
  };
}

const isMain = process.argv[1]
  && pathToFileURL(path.resolve(process.argv[1])).href === import.meta.url;

if (isMain) {
  try {
    const result = await scaffold(process.argv.slice(2));
    process.stdout.write(`${JSON.stringify(result)}\n`);
  } catch (error) {
    const knownError =
      error instanceof ScaffoldError
        ? error
        : new ScaffoldError("WRITE_FAILED", "创建工程骨架失败；未写入未知来源的内容。");

    process.stderr.write(
      `${JSON.stringify({
        schemaVersion: 1,
        ok: false,
        code: knownError.code,
        message: knownError.message,
        ...knownError.details,
      })}\n`,
    );
    process.exitCode = 1;
  }
}