#!/usr/bin/env node
import { Command } from 'commander';
import inquirer from 'inquirer';
import chalk from 'chalk';
import ora from 'ora';
import { fileURLToPath } from 'url';
import { join, dirname } from 'path';
import { logger, FileUtils, getAllTemplates, isRemoteTemplate, isBuiltinTemplate, GitUtils, PackageUtils } from '@zz-tools/utils';
import { readFileSync } from 'fs';

/**
 * 创建项目命令
 */
const createCommand = new Command('create')
    .description('创建新项目')
    .argument('<project-name>', '项目名称')
    .option('-t, --template <template>', '项目模板')
    .option('-o, --output <output>', '输出目录')
    .option('-f, --force', '强制覆盖已存在的目录')
    .option('--no-install', '跳过依赖安装')
    .option('--no-git', '跳过 Git 初始化')
    .action(async (projectName, options) => {
    try {
        await createProject(projectName, options);
    }
    catch (error) {
        logger.error(`创建项目失败: ${error instanceof Error ? error.message : String(error)}`);
        process.exit(1);
    }
});
/**
 * 创建项目
 */
async function createProject(projectName, options) {
    logger.info(`开始创建项目: ${chalk.cyan(projectName)}`);
    // 确定输出目录
    const outputDir = options.output || projectName;
    // 检查目录是否已存在
    if (await FileUtils.exists(outputDir) && !options.force) {
        const { overwrite } = await inquirer.prompt([
            {
                type: 'confirm',
                name: 'overwrite',
                message: `目录 ${outputDir} 已存在，是否覆盖？`,
                default: false
            }
        ]);
        if (!overwrite) {
            logger.info('操作已取消');
            return;
        }
    }
    // 确定模板
    let template = options.template;
    if (!template) {
        const { selectedTemplate } = await inquirer.prompt([
            {
                type: 'list',
                name: 'selectedTemplate',
                message: '请选择项目模板:',
                choices: [
                    ...getAllTemplates().map(t => ({ name: `${t.name} - ${t.description}`, value: t.name })),
                    { name: '自定义 Git 仓库', value: 'custom' }
                ]
            }
        ]);
        if (selectedTemplate === 'custom') {
            const { customTemplate } = await inquirer.prompt([
                {
                    type: 'input',
                    name: 'customTemplate',
                    message: '请输入 Git 仓库地址:',
                    validate: (input) => {
                        if (!input.trim())
                            return '请输入有效的 Git 仓库地址';
                        if (!isRemoteTemplate(input))
                            return '请输入有效的 Git 仓库地址';
                        return true;
                    }
                }
            ]);
            template = customTemplate;
        }
        else {
            template = selectedTemplate;
        }
    }
    // 创建项目目录
    const spinner = ora('创建项目目录...').start();
    try {
        if (await FileUtils.exists(outputDir)) {
            await FileUtils.remove(outputDir);
        }
        await FileUtils.ensureDir(outputDir);
        spinner.succeed('项目目录创建成功');
    }
    catch (error) {
        spinner.fail('创建项目目录失败');
        throw error;
    }
    // 复制模板文件
    if (isBuiltinTemplate(template)) {
        await copyBuiltinTemplate(template, outputDir);
    }
    else if (isRemoteTemplate(template)) {
        await cloneRemoteTemplate(template, outputDir);
    }
    else {
        throw new Error(`不支持的模板类型: ${template}`);
    }
    // 更新项目配置
    await updateProjectConfig(outputDir, projectName);
    // 安装依赖
    if (options.install !== false) {
        await installDependencies(outputDir);
    }
    // 初始化 Git
    if (options.git !== false) {
        await initializeGit(outputDir);
    }
    logger.success(`项目 ${chalk.cyan(projectName)} 创建成功！`);
    logger.info(`\n下一步:`);
    logger.info(`  cd ${outputDir}`);
    if (options.install === false) {
        logger.info(`  pnpm install`);
    }
    logger.info(`  z-service serve`);
}
/**
 * 获取 CLI 安装目录
 */
function getCliDir() {
    const __filename = fileURLToPath(import.meta.url);
    const __dirname = dirname(__filename);
    // 从 dist/commands/create.js 回到 packages/z-cli
    return dirname(dirname(__dirname));
}
/**
 * 复制内置模板
 */
async function copyBuiltinTemplate(templateName, outputDir) {
    const spinner = ora(`复制 ${templateName} 模板...`).start();
    try {
        // 尝试多个可能的模板路径
        const possiblePaths = [
            // 开发环境：从项目根目录的 templates 文件夹
            FileUtils.resolve(process.cwd(), 'templates', templateName),
            // 全局安装：从 CLI 包目录的 templates 文件夹
            join(getCliDir(), 'templates', templateName),
            // 备用路径：从 CLI 包目录的上级目录的 templates 文件夹
            join(dirname(getCliDir()), '..', 'templates', templateName)
        ];
        let templatePath = null;
        for (const path of possiblePaths) {
            if (await FileUtils.exists(path)) {
                templatePath = path;
                break;
            }
        }
        if (!templatePath) {
            throw new Error(`找不到模板 ${templateName}，请检查模板文件是否存在`);
        }
        await FileUtils.copy(templatePath, outputDir);
        spinner.succeed(`${templateName} 模板复制成功`);
    }
    catch (error) {
        spinner.fail(`复制 ${templateName} 模板失败`);
        throw error;
    }
}
/**
 * 克隆远程模板
 */
async function cloneRemoteTemplate(templateUrl, outputDir) {
    const spinner = ora('克隆远程模板...').start();
    try {
        // 解析分支或标签
        const [url, branch] = templateUrl.split('#');
        await GitUtils.clone(url, outputDir, { branch });
        spinner.succeed('远程模板克隆成功');
    }
    catch (error) {
        spinner.fail('克隆远程模板失败');
        throw error;
    }
}
/**
 * 更新项目配置
 */
async function updateProjectConfig(outputDir, projectName, template) {
    const spinner = ora('更新项目配置...').start();
    try {
        const packageJsonPath = FileUtils.join(outputDir, 'package.json');
        if (await FileUtils.exists(packageJsonPath)) {
            const packageJson = await FileUtils.readJson(packageJsonPath);
            // 更新基本信息
            const updatedPackageJson = {
                ...packageJson,
                name: projectName,
                version: '0.1.0',
                description: `${projectName} project created with z-cli`,
                author: '',
                license: 'MIT'
            };
            await FileUtils.writeJson(packageJsonPath, updatedPackageJson);
        }
        spinner.succeed('项目配置更新成功');
    }
    catch (error) {
        spinner.fail('更新项目配置失败');
        throw error;
    }
}
/**
 * 安装依赖
 */
async function installDependencies(outputDir) {
    const spinner = ora('安装依赖...').start();
    try {
        const packageManager = PackageUtils.getPackageManager();
        await PackageUtils.install(outputDir, packageManager);
        spinner.succeed('依赖安装成功');
    }
    catch (error) {
        spinner.fail('依赖安装失败');
        throw error;
    }
}
/**
 * 初始化 Git
 */
async function initializeGit(outputDir) {
    const spinner = ora('初始化 Git 仓库...').start();
    try {
        await GitUtils.init(outputDir);
        await GitUtils.add(outputDir);
        await GitUtils.commit(outputDir, 'feat: initial commit');
        spinner.succeed('Git 仓库初始化成功');
    }
    catch (error) {
        spinner.fail('Git 仓库初始化失败');
        throw error;
    }
}

/**
 * 列表命令
 */
const listCommand = new Command('list')
    .description('列出可用选项')
    .addCommand(new Command('templates')
    .description('列出所有可用模板')
    .action(listTemplates));
/**
 * 列出所有可用模板
 */
function listTemplates() {
    logger.info('可用的项目模板:');
    console.log();
    const templates = getAllTemplates();
    if (templates.length === 0) {
        logger.warn('暂无可用模板');
        return;
    }
    templates.forEach(template => {
        console.log(`  ${chalk.cyan(template.name)}`);
        console.log(`    ${chalk.gray(template.description)}`);
        console.log(`    类型: ${chalk.yellow(template.type)}`);
        if (template.version) {
            console.log(`    版本: ${chalk.green(template.version)}`);
        }
        console.log();
    });
    console.log(chalk.gray('使用示例:'));
    console.log(chalk.gray('  z-cli create my-app -t vue'));
    console.log(chalk.gray('  z-cli create my-app -t react'));
    console.log(chalk.gray('  z-cli create my-app -t https://github.com/user/template.git'));
}

// 获取版本号
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
const packageJson = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
const version = packageJson.version;
const program = new Command();
program
    .name('z-cli')
    .description('Z-Tools 脚手架工具')
    .version(version);
// 注册命令
program.addCommand(createCommand);
program.addCommand(listCommand);
// 解析命令行参数
program.parse();
//# sourceMappingURL=index.js.map
