use std::io;
use std::path::Path;

use crate::command::cmd::Cmd;
use crate::command::env::Env;
use crate::error::BabyError;

pub fn git_cmd(caller: &str, dir: &Path, env: Env, timeout: Option<u64>, args: Vec<String>) -> Cmd {
    Cmd::new(
        caller.to_string(),
        "git",
        args,
        Vec::new(),
        dir.to_path_buf(),
        env,
        timeout,
    )
}

pub fn reject_starts_with_dash(value: &str, kind: &str) -> Result<(), BabyError> {
    if value.starts_with('-') {
        Err(BabyError::InvalidGitArg(format!(
            "{} must not start with '-': `{}`",
            kind, value
        )))
    } else {
        Ok(())
    }
}

pub fn validate_remote_url(url: &str) -> Result<(), BabyError> {
    reject_starts_with_dash(url, "remote url")?;
    let lower = url.to_ascii_lowercase();
    if lower.starts_with("ext::")
        || lower.starts_with("ssh::")
        || lower.starts_with("git::")
        || lower.starts_with("remote-")
    {
        return Err(BabyError::InvalidRemoteUrl(url.to_string()));
    }
    let has_scheme = lower.starts_with("http://")
        || lower.starts_with("https://")
        || lower.starts_with("ssh://")
        || lower.starts_with("git://")
        || lower.starts_with("file://");
    if !has_scheme {
        // Allow scp-style: [user@]host:path or relative/absolute local paths
        if url.contains("://") {
            return Err(BabyError::InvalidRemoteUrl(url.to_string()));
        }
        if url.starts_with('-') {
            return Err(BabyError::InvalidRemoteUrl(url.to_string()));
        }
        if url.contains('\0') || url.contains('\n') || url.contains('\r') {
            return Err(BabyError::InvalidRemoteUrl(url.to_string()));
        }
    }
    Ok(())
}

pub fn validate_revision(rev: &str) -> Result<(), BabyError> {
    crate::share::path::validate_revision_non_empty(rev)?;
    reject_starts_with_dash(rev, "revision")?;
    if rev.contains('\0') || rev.contains('\n') || rev.contains('\r') {
        return Err(BabyError::RevisionInvalid(rev.to_string()));
    }
    Ok(())
}

pub fn validate_config_key(key: &str) -> Result<(), BabyError> {
    reject_starts_with_dash(key, "config key")?;
    if key.is_empty() {
        return Err(BabyError::InvalidGitArg("empty config key".to_string()));
    }
    let mut chars = key.chars();
    let first = chars.next().unwrap();
    if !(first.is_ascii_alphabetic() || first == '_') {
        return Err(BabyError::InvalidGitArg(format!(
            "config key must start with letter or '_': `{}`",
            key
        )));
    }
    for ch in chars {
        if !(ch.is_ascii_alphanumeric() || ch == '-' || ch == '.' || ch == '_') {
            return Err(BabyError::InvalidGitArg(format!(
                "config key contains invalid character `{}` in `{}`",
                ch, key
            )));
        }
    }
    if is_dangerous_config_key(key) {
        return Err(BabyError::InvalidGitArg(format!(
            "refusing to set dangerous config key `{}` via this API; use managed_config_* or explicit global opt-in",
            key
        )));
    }
    Ok(())
}

const DANGEROUS_CONFIG_KEY_PATTERNS: &[&str] = &[
    "core.sshcommand",
    "core.sshcommand.",
    "core.hookspath",
    "core.hookspath.",
    "core.gitproxy",
    "core.gitproxy.",
    "credential.helper",
    "credential.helper.",
    "credential.username",
    "credential.password",
    "credential.token",
    "http.extraheader",
    "http.extraheader.",
    "url.",
    "include.path",
    "includeif.",
    "init.templatedir",
    "protocol.file.allow",
    "protocol.ext.allow",
    "diff.",
    "filter.",
    "gc.auto",
    "gc.autodetach",
    "gpg.format",
    "gpg.program",
    "ssh.variant",
    "alias.",
    "remote.",
    "branch.",
    "tag.",
];

pub fn is_dangerous_config_key(key: &str) -> bool {
    let lower = key.to_ascii_lowercase();
    DANGEROUS_CONFIG_KEY_PATTERNS
        .iter()
        .any(|pat| lower == *pat || lower.starts_with(pat))
}

pub fn classify_spawn_error(prog: String, source: io::Error) -> BabyError {
    BabyError::Spawn {
        prog,
        source,
        stderr: String::new(),
    }
}

pub fn for_each_ref_format(peel: bool) -> String {
    if peel {
        "%(objectname) %(objecttype) %(refname) %(*objectname)".to_string()
    } else {
        "%(objectname) %(objecttype) %(refname)".to_string()
    }
}

pub fn build_for_each_ref_args(
    patterns: &[String],
    sort: Option<&str>,
    limit: Option<u32>,
    start_after: Option<&str>,
    points_at: Option<&str>,
    exclude: &[String],
    peel: bool,
) -> Vec<String> {
    let mut args = vec![
        "for-each-ref".to_string(),
        format!("--format={}", for_each_ref_format(peel)),
    ];
    if let Some(s) = sort {
        args.push("--sort".to_string());
        args.push(s.to_string());
    }
    if let Some(l) = limit {
        args.push("--count".to_string());
        args.push(l.to_string());
    }
    if let Some(sa) = start_after {
        args.push("--start-after".to_string());
        args.push(sa.to_string());
    }
    if let Some(oid) = points_at {
        args.push("--points-at".to_string());
        args.push(oid.to_string());
    }
    for p in patterns {
        args.push(p.clone());
    }
    for p in exclude {
        args.push("--exclude".to_string());
        args.push(p.clone());
    }
    args
}

pub enum CatFileSubcommand {
    BatchCheck,
    Batch,
    Blob,
}

pub fn git_cat_file_cmd(
    dir: &Path,
    env: Env,
    oid: &gix::ObjectId,
    subcommand: CatFileSubcommand,
) -> Cmd {
    let mut args = vec!["cat-file".to_string()];
    match subcommand {
        CatFileSubcommand::BatchCheck => {
            args.push("--batch-check".to_string());
        }
        CatFileSubcommand::Batch => {
            args.push("--batch".to_string());
        }
        CatFileSubcommand::Blob => {
            args.push("blob".to_string());
            args.push("--end-of-options".to_string());
            args.push(oid.to_string());
        }
    }
    git_cmd("gitbaby::blob", dir, env, None, args)
}

pub fn git_hash_object_cmd(dir: &Path, env: Env, path: Option<&str>) -> Cmd {
    let mut args = vec![
        "hash-object".to_string(),
        "--stdin".to_string(),
        "-w".to_string(),
    ];
    if let Some(p) = path {
        args.push("--path".to_string());
        args.push(p.to_string());
    }
    git_cmd("gitbaby::blob", dir, env, None, args)
}

pub enum ConfigScope {
    Global,
    Local,
}

pub enum ConfigOp {
    Get,
    Set,
    Add,
    UnsetAll,
    GetAll,
    GetRegexp,
}

pub fn build_config_cmd(
    caller: &str,
    dir: &Path,
    env: Env,
    scope: ConfigScope,
    op: ConfigOp,
    key: &str,
    value: Option<&str>,
) -> Result<Cmd, BabyError> {
    validate_config_key(key)?;
    if let Some(v) = value {
        reject_starts_with_dash(v, "config value")?;
        if v.contains('\0') {
            return Err(BabyError::InvalidGitArg(format!(
                "config value contains NUL: `{}`",
                v
            )));
        }
    }
    let mut args = vec!["config".to_string()];
    if matches!(scope, ConfigScope::Global) {
        args.push("--global".to_string());
    }
    match op {
        ConfigOp::Get => args.push("--get".to_string()),
        ConfigOp::Set => {}
        ConfigOp::Add => args.push("--add".to_string()),
        ConfigOp::UnsetAll => args.push("--unset-all".to_string()),
        ConfigOp::GetAll => args.push("--get-all".to_string()),
        ConfigOp::GetRegexp => args.push("--get-regexp".to_string()),
    }
    args.push(key.to_string());
    if let Some(v) = value
        && matches!(op, ConfigOp::Set | ConfigOp::Add)
    {
        args.push(v.to_string());
    }
    Ok(git_cmd(caller, dir, env, None, args))
}

pub enum ArchiveFormatArg {
    Tar,
    TarGz,
    TarBz2,
    Zip,
}

pub fn build_archive_cmd(
    caller: &str,
    dir: &Path,
    env: Env,
    format: ArchiveFormatArg,
    prefix: Option<&str>,
    commit: &str,
    paths: &[String],
) -> Result<Cmd, BabyError> {
    validate_revision(commit)?;
    if let Some(p) = prefix {
        reject_starts_with_dash(p, "archive prefix")?;
        if p.contains('\0') || p.contains('\n') || p.contains('\r') {
            return Err(BabyError::InvalidGitArg(format!(
                "archive prefix contains control character: `{}`",
                p
            )));
        }
    }
    for p in paths {
        reject_starts_with_dash(p, "archive path")?;
    }
    let mut args = vec!["archive".to_string()];
    match format {
        ArchiveFormatArg::Tar => args.push("--format=tar".to_string()),
        ArchiveFormatArg::TarGz => args.push("--format=tar.gz".to_string()),
        ArchiveFormatArg::TarBz2 => args.push("--format=tar.bz2".to_string()),
        ArchiveFormatArg::Zip => args.push("--format=zip".to_string()),
    }
    if let Some(p) = prefix {
        args.push(format!("--prefix={}", p));
    }
    args.push("--end-of-options".to_string());
    args.push(commit.to_string());
    if !paths.is_empty() {
        args.push("--".to_string());
        for p in paths {
            args.push(p.clone());
        }
    }
    Ok(git_cmd(caller, dir, env, None, args))
}
pub enum RemoteOp {
    Add,
    Remove,
    GetUrl,
    Show,
}

pub enum RemoteMirror {
    Default,
    Push,
    Fetch,
}

pub fn build_remote_op_cmd(
    caller: &str,
    dir: &std::path::Path,
    env: Env,
    op: RemoteOp,
    name: &str,
    url: Option<&str>,
    mirror: RemoteMirror,
) -> Result<Cmd, BabyError> {
    reject_starts_with_dash(name, "remote name")?;
    if name.is_empty() {
        return Err(BabyError::InvalidGitArg("remote name is empty".to_string()));
    }
    if let Some(u) = url {
        validate_remote_url(u)?;
    }
    let mut args = vec!["remote".to_string()];
    match op {
        RemoteOp::Add => args.push("add".to_string()),
        RemoteOp::Remove => args.push("rm".to_string()),
        RemoteOp::GetUrl => args.push("get-url".to_string()),
        RemoteOp::Show => args.push("show".to_string()),
    }
    match mirror {
        RemoteMirror::Default => {}
        RemoteMirror::Push => args.push("--mirror=push".to_string()),
        RemoteMirror::Fetch => args.push("--mirror=fetch".to_string()),
    }
    args.push("--end-of-options".to_string());
    args.push(name.to_string());
    if let Some(u) = url {
        args.push(u.to_string());
    }
    Ok(git_cmd(caller, dir, env, None, args))
}

pub fn build_ls_remote_cmd(
    caller: &str,
    dir: &std::path::Path,
    env: Env,
    url: &str,
    refs: &[String],
) -> Result<Cmd, BabyError> {
    validate_remote_url(url)?;
    for r in refs {
        reject_starts_with_dash(r, "ref pattern")?;
    }
    let mut args = vec![
        "ls-remote".to_string(),
        "--end-of-options".to_string(),
        url.to_string(),
    ];
    for r in refs {
        args.push(r.clone());
    }
    Ok(git_cmd(caller, dir, env, None, args))
}

pub fn build_init_cmd(
    caller: &str,
    dir: &std::path::Path,
    env: Env,
    path: &str,
    bare: bool,
    object_format: Option<&str>,
) -> Result<Cmd, BabyError> {
    if path.starts_with('-') {
        return Err(BabyError::InvalidGitArg(format!(
            "init path must not start with '-': `{}`",
            path
        )));
    }
    if path.contains('\0') {
        return Err(BabyError::InvalidGitArg(format!(
            "init path contains NUL: `{}`",
            path
        )));
    }
    if let Some(of) = object_format {
        reject_starts_with_dash(of, "object-format")?;
    }
    let mut args = vec!["init".to_string()];
    if bare {
        args.push("--bare".to_string());
    }
    if let Some(of) = object_format {
        args.push(format!("--object-format={}", of));
    }
    args.push("--end-of-options".to_string());
    args.push(path.to_string());
    Ok(git_cmd(caller, dir, env, None, args))
}

pub fn build_fast_import_cmd(caller: &str, dir: &std::path::Path, env: Env) -> Cmd {
    let args = vec![
        "fast-import".to_string(),
        "--force".to_string(),
        "--done".to_string(),
    ];
    git_cmd(caller, dir, env, None, args)
}

pub fn build_gc_cmd(caller: &str, dir: &std::path::Path, env: Env, prune_now: bool) -> Cmd {
    let mut args = vec!["gc".to_string()];
    if prune_now {
        args.push("--prune=now".to_string());
    }
    git_cmd(caller, dir, env, None, args)
}

pub fn build_pack_refs_cmd(caller: &str, dir: &std::path::Path, env: Env) -> Cmd {
    let args = vec!["pack-refs".to_string(), "--all".to_string()];
    git_cmd(caller, dir, env, None, args)
}

pub fn build_fetch_cmd(
    caller: &str,
    dir: &std::path::Path,
    env: Env,
    remote_url: &str,
    refspecs: &[String],
    prune: bool,
    tags: bool,
) -> Result<Cmd, BabyError> {
    validate_remote_url(remote_url)?;
    for r in refspecs {
        reject_starts_with_dash(r, "refspec")?;
    }
    let mut args = vec!["fetch".to_string()];
    if prune {
        args.push("--prune".to_string());
    }
    if !tags {
        args.push("--no-tags".to_string());
    }
    args.push("--end-of-options".to_string());
    args.push(remote_url.to_string());
    for r in refspecs {
        args.push(r.clone());
    }
    Ok(git_cmd(caller, dir, env, None, args))
}

pub fn build_push_cmd(
    caller: &str,
    dir: &std::path::Path,
    env: Env,
    remote_url: &str,
    refspecs: &[String],
    force: bool,
) -> Result<Cmd, BabyError> {
    validate_remote_url(remote_url)?;
    for r in refspecs {
        reject_starts_with_dash(r, "refspec")?;
    }
    let mut args = vec!["push".to_string()];
    if force {
        args.push("--force".to_string());
    }
    args.push("--end-of-options".to_string());
    args.push(remote_url.to_string());
    for r in refspecs {
        args.push(r.clone());
    }
    Ok(git_cmd(caller, dir, env, None, args))
}