OpenixCLI CLI 模块深度解析：命令行接口设计

use cli::{Cli, Commands};
use commands::FlashArgs;

/// CLI 主结构 - 使用 clap Parser derive 宏
#[derive(Parser)]
#[command(name = "openixcli")]
#[command(about = "Firmware flashing CLI tool for Allwinner chips", long_about = None)]
#[command(version)]
pub struct Cli {
    /// 要执行的子命令（默认为 TUI）
    #[command(subcommand)]
    pub command: Option<Commands>,

    /// 启用详细输出
    #[arg(short, long, global = true, help = "Enable verbose output")]
    pub verbose: bool,
}

/// 可用的 CLI 命令
#[derive(Subcommand)]
pub enum Commands {
    /// 扫描连接的设备
    Scan {
        /// 获取详细设备信息（需要初始化设备）
        #[arg(short = 'l', long, help = "Get detailed device information")]
        detailed: bool,
    },

    /// 刷写固件到设备
    Flash {
        /// 固件文件路径
        #[arg(help = "Path to firmware file")]
        firmware: String,

        /// USB 总线号
        #[arg(short, long, help = "USB bus number")]
        bus: Option<u8>,

        /// USB 端口号
        #[arg(short = 'P', long, help = "USB port number")]
        port: Option<u8>,

        /// 启用写入后验证
        #[arg(short = 'V', long, default_value = "true",
              help = "Enable verification after write")]
        verify: bool,

        /// 刷写模式
        /// - partition: 仅刷写指定分区
        /// - keep_data: 保留现有数据
        /// - partition_erase: 刷写前擦除分区
        /// - full_erase: 刷写前完全擦除
        #[arg(short, long, default_value = "full_erase",
              help = "Flash mode: partition, keep_data, partition_erase, full_erase")]
        mode: String,

        /// 要刷写的分区（逗号分隔）
        #[arg(short = 'p', long,
              help = "Partitions to flash (comma-separated)")]
        partitions: Option<String>,

        /// 刷写后操作
        /// - reboot: 重启设备
        /// - poweroff: 关闭设备电源
        /// - shutdown: 关闭设备
        #[arg(short = 'a', long, default_value = "reboot",
              help = "Post-flash action: reboot, poweroff, shutdown")]
        post_action: String,
    },

    /// 启动交互式 TUI 模式
    Tui,
}

/// Flash 命令参数
///
/// 将 CLI 解析结果转换为内部模块可用的结构化数据
pub struct FlashArgs {
    pub firmware_path: PathBuf,      // 固件路径
    pub bus: Option<u8>,             // USB 总线号
    pub port: Option<u8>,            // USB 端口号
    pub verify: bool,                // 验证开关
    pub mode: FlashMode,             // 刷写模式（枚举）
    pub partitions: Option<Vec<String>>, // 分区列表
    pub post_action: String,         // 后续操作
    pub verbose: bool,               // 详细模式
}

/// 刷写模式选项
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FlashMode {
    Partition,       // 仅刷写指定分区
    KeepData,        // 保留现有数据
    PartitionErase,  // 刷写前擦除分区
    FullErase,       // 刷写前完全擦除
}

/// 实现 FromStr trait - 支持字符串解析
impl FromStr for FlashMode {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s {
            "partition" => Ok(Self::Partition),
            "keep_data" => Ok(Self::KeepData),
            "partition_erase" => Ok(Self::PartitionErase),
            "full_erase" => Ok(Self::FullErase),
            _ => Err(format!("Invalid flash mode: {}", s)),
        }
    }
}

/// 实现 Display trait - 支持字符串输出
impl std::fmt::Display for FlashMode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            FlashMode::Partition => write!(f, "partition"),
            FlashMode::KeepData => write!(f, "keep_data"),
            FlashMode::PartitionErase => write!(f, "partition_erase"),
            FlashMode::FullErase => write!(f, "full_erase"),
        }
    }
}

use clap::Parser;
use std::str::FromStr;

mod cli;
mod commands;

use cli::{Cli, Commands};
use commands::FlashArgs;
use utils::TermLogger;

/// 初始化日志系统
fn setup_logging(verbose: bool) {
    if let Err(e) = TermLogger::init(verbose) {
        eprintln!("Failed to initialize logger: {}", e);
    }
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // 1. 解析命令行参数
    let cli = Cli::parse();

    // 2. 命令路由
    match cli.command {
        // 无子命令或 TUI -> 启动交互界面
        None | Some(Commands::Tui) => {
            tui::run().await?;
        }

        // Scan 命令 -> 扫描 USB 设备
        Some(Commands::Scan { detailed }) => {
            setup_logging(cli.verbose);
            commands::scan::execute(detailed).await?;
        }

        // Flash 命令 -> 执行固件刷写
        Some(Commands::Flash {
            firmware,
            bus,
            port,
            verify,
            mode,
            partitions,
            post_action,
        }) => {
            setup_logging(cli.verbose);

            // 3. 解析刷写模式
            let flash_mode = FlashMode::from_str(&mode)
                .map_err(|e| anyhow::anyhow!("{}", e))?;

            // 4. 解析分区列表（逗号分隔）
            let partition_list = partitions
                .map(|s| s.split(',')
                       .map(|p| p.trim().to_string())
                       .collect());

            // 5. 构建 FlashArgs
            let args = FlashArgs {
                firmware_path: firmware.into(),
                bus,
                port,
                verify,
                mode: flash_mode,
                partitions: partition_list,
                post_action,
                verbose: cli.verbose,
            };

            // 6. 执行刷写
            commands::flash::execute(args).await?;
        }
    }

    Ok(())
}

// CLI 字符串参数 -> 内部类型

// 1. 固件路径：String -> PathBuf
let firmware_path: PathBuf = firmware.into();

// 2. 刷写模式：String -> FlashMode (通过 FromStr)
let mode: FlashMode = FlashMode::from_str("full_erase")?;
// 结果: FlashMode::FullErase

// 3. 分区列表：Option<String> -> Option<Vec<String>>
let partitions: Option<Vec<String>> = Some("boot,rootfs,userdata")
    .map(|s| s.split(',')
           .map(|p| p.trim().to_string())
           .collect());
// 结果: Some(["boot", "rootfs", "userdata"])

#[arg(short, long, global = true, help = "Enable verbose output")]
pub verbose: bool,

#[command(subcommand)]
pub command: Option<Commands>,

match cli.command {
    None | Some(Commands::Tui) => {
        tui::run().await?;  // 无子命令默认启动 TUI
    }
    // ...
}

#[arg(short, long)]          // bus -> -b, --bus
#[arg(short = 'P', long)]    // port -> -P, --port (避免与 partitions 的 -p 冲突)
#[arg(short = 'p', long)]    // partitions -> -p, --partitions

#[arg(default_value = "true")]    // verify 默认为 true
#[arg(default_value = "reboot")]  // post_action 默认为 reboot
#[arg(default_value = "full_erase")]  // mode 默认为 full_erase

impl FromStr for FlashMode {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.trim() {
            "partition" => Ok(Self::Partition),
            "keep_data" => Ok(Self::KeepData),
            "partition_erase" => Ok(Self::PartitionErase),
            "full_erase" => Ok(Self::FullErase),
            _ => Err(format!("Invalid flash mode: {}. Valid modes: partition, keep_data, partition_erase, full_erase", s)),
        }
    }
}

/// 扫描连接的设备
Scan {
    /// 获取详细设备信息（需要初始化设备）
    #[arg(short = 'l', long)]
    detailed: bool,
},

FlashArgs {
    firmware_path: PathBuf::from("firmware.fex"),
    bus: Some(1),
    port: Some(2),
    verify: true,
    mode: FlashMode::PartitionErase,
    partitions: Some(["boot", "rootfs", "userdata"]),
    post_action: "reboot",
    verbose: true,
}

// 无效刷写模式
let result = FlashMode::from_str("invalid_mode");
// Err("Invalid flash mode: invalid_mode")

// 使用 ? 操作符传播错误
let mode = FlashMode::from_str(&mode_str)
    .map_err(|e| anyhow::anyhow!("{}", e))?;