//! Branch/HEAD plumbing. All mutators are called under the common .git lock.
use crate::Result;
use crate::{HeadInfo, checkout::write_tree_to_worktree, head_info, repo::error};

/// Switch a branch, tag, or commit; optionally create a branch at HEAD.
#[derive(serde::Serialize, serde::Deserialize)]
pub(crate) struct CheckoutParams {
    /// Plain name under /repos (a-z0-9._-, no '..'), or absolute path under /plugins/ or /repos/ (no empty, '.' or '..' segments or trailing slash).
    pub repo: String,
    /// Branch, tag or commit revision; with create=true, the new branch name.
    pub target: String,
    /// Create a new branch at HEAD and switch to it (default false).
    pub create: Option<bool>,
    /// Discard overwritten tracked changes, never untracked files (default false).
    pub force: Option<bool>,
}

/// Create a local branch, optionally switching the worktree to it.
#[derive(serde::Serialize, serde::Deserialize)]
pub(crate) struct BranchCreateParams {
    /// Plain name under /repos (a-z0-9._-, no '..'), or absolute path under /plugins/ or /repos/ (no empty, '.' or '..' segments or trailing slash).
    pub repo: String,
    /// Short new branch name.
    pub name: String,
    /// Starting commit revision, default HEAD.
    pub from: Option<String>,
    /// Switch to the new branch, refusing overwritten dirty changes (default false).
    pub checkout: Option<bool>,
}

/// Delete a local branch.
#[derive(serde::Serialize, serde::Deserialize)]
pub(crate) struct BranchDeleteParams {
    /// Plain name under /repos (a-z0-9._-, no '..'), or absolute path under /plugins/ or /repos/ (no empty, '.' or '..' segments or trailing slash).
    pub repo: String,
    /// Short existing branch name.
    pub name: String,
    /// Allow deletion when not merged into HEAD (default false). Current branch is always protected.
    pub force: Option<bool>,
}

/// Result of a checkout or branch creation.
#[derive(serde::Serialize, serde::Deserialize)]
pub(crate) struct CheckoutResult {
    /// HEAD after the operation.
    pub head: HeadInfo,
    /// Full branch reference created, if any.
    pub created: Option<String>,
    /// Unsupported worktree features (symlinks/submodules/chmod); raw content has no filters or eol conversion.
    pub warnings: Vec<String>,
}

/// Deleted branch identity.
#[derive(serde::Serialize, serde::Deserialize)]
pub(crate) struct BranchDeleted {
    /// Full reference deleted.
    pub reference: String,
}

/// Reflog-only writes use a fallback identity when the repository has none.
pub(crate) fn reflog_signature(repo: &gix::Repository) -> Result<gix::actor::Signature> {
    if let Some(signature) = repo
        .committer()
        .transpose()
        .map_err(|e| error("reflog identity", e))?
    {
        return signature
            .to_owned()
            .map_err(|e| error("reflog identity", e));
    }
    let config = repo.config_snapshot();
    let name = std::env::var("GIT_COMMITTER_NAME")
        .ok()
        .or_else(|| config.string("user.name").map(|s| s.to_string()))
        .or_else(|| std::env::var("USER").ok())
        .unwrap_or_else(|| "Sausage".into());
    let email = std::env::var("GIT_COMMITTER_EMAIL")
        .ok()
        .or_else(|| config.string("user.email").map(|s| s.to_string()))
        .unwrap_or_else(|| {
            format!(
                "{}@{}",
                std::env::var("USER").unwrap_or_else(|_| "sausage".into()),
                std::env::var("HOSTNAME").unwrap_or_else(|_| "localhost".into())
            )
        });
    let seconds = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap()
        .as_secs() as i64;
    Ok(gix::actor::Signature {
        name: name.into(),
        email: email.into(),
        time: gix::date::Time::new(seconds, 0),
    })
}

/// Publish references and their reflog entries without requiring a commit identity.
pub(crate) fn edit_refs(
    repo: &gix::Repository,
    edits: Vec<gix::refs::transaction::RefEdit>,
) -> Result<Vec<String>> {
    let signature = reflog_signature(repo)?;
    let mut time = Default::default();
    repo.edit_references_as(edits, Some(signature.to_ref(&mut time)))
        .map_err(|e| error("checkout refs", e))?;
    Ok(Vec::new())
}

pub(crate) fn branch_name(name: &str) -> Result<String> {
    if name.is_empty() || name.starts_with('-') || name.starts_with("refs/") || name == "HEAD" {
        return Err(error("branch name", "expected short local branch name"));
    }
    let full = format!("refs/heads/{name}");
    let _: gix::refs::FullName = full
        .as_str()
        .try_into()
        .map_err(|e| error("branch name", e))?;
    Ok(full)
}

fn unused(repo: &gix::Repository, name: &str) -> Result<()> {
    if repo
        .try_find_reference(name)
        .map_err(|e| error("branch lookup", e))?
        .is_some()
    {
        return Err(error("branch create", "branch already exists"));
    }
    Ok(())
}

pub(crate) fn resolve(repo: &gix::Repository, rev: &str) -> Result<gix::ObjectId> {
    Ok(repo
        .rev_parse_single(rev)
        .map_err(|e| error("checkout revision", e))?
        .object()
        .map_err(|e| error("checkout object", e))?
        .peel_to_kind(gix::objs::Kind::Commit)
        .map_err(|e| error("checkout commit", e))?
        .id)
}

fn old_tree(repo: &gix::Repository) -> Result<Option<gix::ObjectId>> {
    if repo
        .head()
        .map_err(|e| error("checkout HEAD", e))?
        .is_unborn()
    {
        return Ok(None);
    }
    let id = resolve(repo, "HEAD")?;
    Ok(Some(
        repo.find_commit(id)
            .map_err(|e| error("checkout HEAD", e))?
            .tree_id()
            .map_err(|e| error("checkout HEAD tree", e))?
            .detach(),
    ))
}

fn switch(
    repo: &gix::Repository,
    id: gix::ObjectId,
    branch: Option<&str>,
    create: bool,
    force: bool,
) -> Result<Vec<String>> {
    crate::merge::ensure_idle(repo)?;
    if let Some(branch) = branch {
        crate::worktrees::ensure_available(repo, branch)?;
    }
    let tree = repo
        .find_commit(id)
        .map_err(|e| error("checkout commit", e))?
        .tree_id()
        .map_err(|e| error("checkout tree", e))?
        .detach();
    // Validate identity before publishing worktree/index. edit_refs resolves the same
    // immutable repository config again when publishing refs, but must not discover a
    // malformed identity only after files have changed.
    repo.committer()
        .transpose()
        .map_err(|e| error("reflog identity", e))?;
    let mut warnings = write_tree_to_worktree(repo, old_tree(repo)?, tree, force)?;
    // Index already published. Refs last, using gix transactions (including packed refs and reflogs).
    use gix::refs::{
        Target,
        transaction::{Change, PreviousValue, RefEdit},
    };
    let mut edits = Vec::new();
    if create {
        let name = branch.ok_or_else(|| error("checkout", "missing new branch"))?;
        edits.push(RefEdit {
            name: name.try_into().map_err(|e| error("branch name", e))?,
            deref: false,
            change: Change::Update {
                log: Default::default(),
                expected: PreviousValue::MustNotExist,
                new: Target::Object(id),
            },
        });
    }
    let target = match branch {
        Some(name) => Target::Symbolic(name.try_into().map_err(|e| error("branch name", e))?),
        None => Target::Object(id),
    };
    edits.push(RefEdit {
        name: "HEAD".try_into().map_err(|e| error("HEAD", e))?,
        deref: false,
        change: Change::Update {
            log: Default::default(),
            expected: PreviousValue::Any,
            new: target,
        },
    });
    warnings.extend(edit_refs(repo, edits)?);
    Ok(warnings)
}

pub(crate) fn checkout(repo: &gix::Repository, p: CheckoutParams) -> Result<CheckoutResult> {
    crate::repo::worktree(repo)?;
    let create = p.create.unwrap_or(false);
    let (id, branch) = if create {
        let name = branch_name(&p.target)?;
        crate::worktrees::ensure_available(repo, &name)?;
        unused(repo, &name)?;
        (resolve(repo, "HEAD")?, Some(name))
    } else {
        // Local branches take precedence over tags; tags and all other revisions detach HEAD.
        let name = if p.target.starts_with("refs/heads/") {
            p.target.clone()
        } else {
            format!("refs/heads/{}", p.target)
        };
        // Revision operators are not valid reference names. Only probe a local
        // branch when its full name validates; otherwise let rev_parse interpret it.
        let reference = if <gix::refs::FullName as TryFrom<&str>>::try_from(name.as_str()).is_ok() {
            crate::worktrees::ensure_available(repo, &name)?;
            repo.try_find_reference(name.as_str())
                .map_err(|e| error("checkout branch", e))?
        } else {
            None
        };
        if let Some(mut reference) = reference {
            let id = reference
                .peel_to_id()
                .map_err(|e| error("checkout branch", e))?
                .detach();
            (id, Some(name))
        } else {
            (resolve(repo, &p.target)?, None)
        }
    };
    let warnings = switch(
        repo,
        id,
        branch.as_deref(),
        create,
        p.force.unwrap_or(false),
    )?;
    Ok(CheckoutResult {
        head: head_info(repo)?,
        created: if create { branch } else { None },
        warnings,
    })
}

pub(crate) fn create(repo: &gix::Repository, p: BranchCreateParams) -> Result<CheckoutResult> {
    let name = branch_name(&p.name)?;
    if p.checkout.unwrap_or(false) {
        crate::worktrees::ensure_available(repo, &name)?;
    }
    unused(repo, &name)?;
    let id = resolve(repo, p.from.as_deref().unwrap_or("HEAD"))?;
    let warnings = if p.checkout.unwrap_or(false) {
        switch(repo, id, Some(&name), true, false)?
    } else {
        use gix::refs::{
            Target,
            transaction::{Change, PreviousValue, RefEdit},
        };
        edit_refs(
            repo,
            vec![RefEdit {
                name: name
                    .as_str()
                    .try_into()
                    .map_err(|e| error("branch name", e))?,
                deref: false,
                change: Change::Update {
                    log: Default::default(),
                    expected: PreviousValue::MustNotExist,
                    new: Target::Object(id),
                },
            }],
        )?
    };
    Ok(CheckoutResult {
        head: head_info(repo)?,
        created: Some(name),
        warnings,
    })
}

pub(crate) fn delete(repo: &gix::Repository, p: BranchDeleteParams) -> Result<BranchDeleted> {
    crate::merge::ensure_idle(repo)?;
    let name = branch_name(&p.name)?;
    crate::worktrees::ensure_available(repo, &name)?;
    if head_info(repo)?.branch.as_deref() == Some(&name) {
        return Err(error("branch delete", "cannot delete current branch"));
    }
    let mut reference = repo
        .find_reference(name.as_str())
        .map_err(|e| error("branch delete", e))?;
    let tip = reference
        .peel_to_id()
        .map_err(|e| error("branch delete", e))?
        .detach();
    if !p.force.unwrap_or(false) {
        let head = resolve(repo, "HEAD")?;
        // Explicit traversal avoids commit-graph mmap on WASI; includes every parent.
        let walk = repo
            .find_commit(head)
            .map_err(|e| error("branch merged", e))?
            .ancestors()
            .use_commit_graph(false)
            .all()
            .map_err(|e| error("branch merged", e))?;
        let mut merged = false;
        for entry in walk {
            if entry.map_err(|e| error("branch merged", e))?.id == tip {
                merged = true;
                break;
            }
        }
        if !merged {
            return Err(error(
                "branch delete",
                "branch is not merged into HEAD; use force",
            ));
        }
    }
    reference.delete().map_err(|e| error("branch delete", e))?;
    Ok(BranchDeleted { reference: name })
}