//! Git tree and file tools.

use super::ctx::GitToolCtx;
use agent::ToolRegistry;
use base64::Engine;

async fn git_file_content_exec(ctx: GitToolCtx, args: serde_json::Value) -> Result<serde_json::Value, String> {
    let p: serde_json::Map<String, serde_json::Value> = serde_json::from_value(args).map_err(|e| e.to_string())?;
    let project_name = p.get("project_name").and_then(|v| v.as_str()).ok_or("missing project_name")?;
    let repo_name = p.get("repo_name").and_then(|v| v.as_str()).ok_or("missing repo_name")?;
    let path = p.get("path").and_then(|v| v.as_str()).ok_or("missing path")?;
    let rev = p.get("rev").and_then(|v| v.as_str()).map(|s| s.to_string()).unwrap_or_else(|| "HEAD".to_string());

    let domain = ctx.open_repo(project_name, repo_name).await?;
    let oid = if rev.len() >= 40 {
        git::commit::types::CommitOid::new(&rev)
    } else {
        domain.commit_get_prefix(&rev).map_err(|e| e.to_string())?.oid
    };

    let entry = domain.tree_entry_by_path_from_commit(&oid, path).map_err(|e| e.to_string())?;
    let blob_info = domain.blob_get(&entry.oid).map_err(|e| e.to_string())?;

    let content = domain.blob_content(&entry.oid).map_err(|e| e.to_string())?;
    let (display_content, is_binary) = if blob_info.is_binary {
        (base64::engine::general_purpose::STANDARD.encode(&content.content), true)
    } else {
        (String::from_utf8_lossy(&content.content).to_string(), false)
    };

    Ok(serde_json::json!({
        "path": path,
        "oid": entry.oid.to_string(),
        "size": blob_info.size,
        "content": display_content,
        "is_binary": is_binary
    }))
}

async fn git_tree_ls_exec(ctx: GitToolCtx, args: serde_json::Value) -> Result<serde_json::Value, String> {
    let p: serde_json::Map<String, serde_json::Value> = serde_json::from_value(args).map_err(|e| e.to_string())?;
    let project_name = p.get("project_name").and_then(|v| v.as_str()).ok_or("missing project_name")?;
    let repo_name = p.get("repo_name").and_then(|v| v.as_str()).ok_or("missing repo_name")?;
    let dir_path = p.get("path").and_then(|v| v.as_str()).map(|s| s.to_string());
    let rev = p.get("rev").and_then(|v| v.as_str()).map(|s| s.to_string()).unwrap_or_else(|| "HEAD".to_string());

    let domain = ctx.open_repo(project_name, repo_name).await?;
    let commit_oid = if rev.len() >= 40 {
        git::commit::types::CommitOid::new(&rev)
    } else {
        domain.commit_get_prefix(&rev).map_err(|e| e.to_string())?.oid
    };

    let entries = match dir_path {
        Some(ref dp) => {
            let entry = domain.tree_entry_by_path(&commit_oid, dp).map_err(|e| e.to_string())?;
            domain.tree_list(&entry.oid).map_err(|e| e.to_string())?
        }
        None => domain.tree_list(&commit_oid).map_err(|e| e.to_string())?,
    };

    let result: Vec<_> = entries.iter().map(|e| {
        serde_json::json!({
            "name": e.name,
            "oid": e.oid.to_string(),
            "kind": e.kind,
            "is_binary": e.is_binary
        })
    }).collect();

    Ok(serde_json::to_value(result).map_err(|e| e.to_string())?)
}

async fn git_file_history_exec(ctx: GitToolCtx, args: serde_json::Value) -> Result<serde_json::Value, String> {
    let p: serde_json::Map<String, serde_json::Value> = serde_json::from_value(args).map_err(|e| e.to_string())?;
    let project_name = p.get("project_name").and_then(|v| v.as_str()).ok_or("missing project_name")?;
    let repo_name = p.get("repo_name").and_then(|v| v.as_str()).ok_or("missing repo_name")?;
    let path = p.get("path").and_then(|v| v.as_str()).ok_or("missing path")?;
    let limit = p.get("limit").and_then(|v| v.as_u64()).unwrap_or(20) as usize;

    let domain = ctx.open_repo(project_name, repo_name).await?;
    let commits = domain.commit_log(Some("HEAD"), 0, 500).map_err(|e| e.to_string())?;

    let result: Vec<_> = commits.iter()
        .filter(|c| domain.tree_entry_by_path(&c.tree_id, path).is_ok())
        .take(limit)
        .map(|c| flatten_commit(c))
        .collect();

    Ok(serde_json::to_value(result).map_err(|e| e.to_string())?)
}

fn flatten_commit(c: &git::commit::types::CommitMeta) -> serde_json::Value {
    use chrono::TimeZone;
    let ts = c.author.time_secs + (c.author.offset_minutes as i64 * 60);
    let author_time = chrono::Utc.timestamp_opt(ts, 0).single()
        .map(|dt| dt.to_rfc3339()).unwrap_or_else(|| format!("{}", c.author.time_secs));
    let oid = c.oid.to_string();
    serde_json::json!({
        "oid": oid.clone(),
        "short_oid": oid.get(..7).unwrap_or(&oid).to_string(),
        "message": c.message, "summary": c.summary,
        "author_name": c.author.name, "author_email": c.author.email, "author_time": author_time,
        "committer_name": c.committer.name, "committer_email": c.committer.email,
        "parent_oids": c.parent_ids.iter().map(|p| p.to_string()).collect::<Vec<_>>(),
        "tree_oid": c.tree_id.to_string()
    })
}

macro_rules! register_fn {
    ($registry:expr, $name:expr, $exec:expr) => {
        let handler_fn = move |ctx: agent::ToolContext, args: serde_json::Value| async move {
            let gctx = super::ctx::GitToolCtx::new(ctx);
            $exec(gctx, args)
                .await
                .map_err(agent::ToolError::ExecutionError)
        };
        $registry.register_fn($name, handler_fn);
    };
}

pub fn register_git_tools(registry: &mut ToolRegistry) {
    register_fn!(registry, "git_file_content", git_file_content_exec);
    register_fn!(registry, "git_tree_ls", git_tree_ls_exec);
    register_fn!(registry, "git_file_history", git_file_history_exec);
}