use crate::client::Client;
use crate::config;
use crate::output;
use clap::{Args, Subcommand};
use serde::Deserialize;

#[derive(Args)]
pub struct BranchArgs {
    #[command(subcommand)]
    pub command: BranchCommand,
}

#[derive(Subcommand)]
pub enum BranchCommand {
    /// List branches
    List {
        /// Repository (org/repo)
        repo: Option<String>,
    },
}

#[derive(Debug, Deserialize)]
struct Branch {
    name: Option<String>,
    #[serde(alias = "sha")]
    target: Option<String>,
}

pub async fn run(args: BranchArgs) -> Result<(), Box<dyn std::error::Error>> {
    match args.command {
        BranchCommand::List { repo } => list(repo.as_deref()).await,
    }
}

async fn list(repo: Option<&str>) -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::from_config()?;
    let (org, name) = config::resolve_repo(repo)?;

    let resp: serde_json::Value = client.get(&format!("/{org}/{name}/branches")).await?;

    if output::is_json() {
        output::print_json(&resp);
        return Ok(());
    }

    let branches: Vec<Branch> = if let Some(arr) = resp.get("branches") {
        serde_json::from_value(arr.clone()).unwrap_or_default()
    } else if let Some(arr) = resp.get("data") {
        serde_json::from_value(arr.clone()).unwrap_or_default()
    } else {
        serde_json::from_value(resp).unwrap_or_default()
    };

    output::header(&format!("Branches ({org}/{name})"));

    let rows: Vec<Vec<String>> = branches
        .iter()
        .map(|b| {
            let sha = b
                .target
                .as_deref()
                .unwrap_or("")
                .chars()
                .take(8)
                .collect::<String>();
            vec![b.name.clone().unwrap_or_default(), sha]
        })
        .collect();

    output::print_table(&["NAME", "SHA"], &rows);

    Ok(())
}