use std::path::Path;

use anyhow::{Context, Result};

// History walks re-decode the same commit objects without one; sized
// generously, a walk can cover a large portion of the history.
const OBJECT_CACHE_BYTES: usize = 64 * 1024 * 1024;

// One `open` per operation instead of every helper re-opening by path.
pub struct Repo {
    pub(crate) inner: gix::Repository,
}

impl Repo {
    pub fn open(workdir: &Path) -> Result<Self> {
        Ok(Self {
            inner: gix::open(workdir)?,
        })
    }

    pub fn try_open(workdir: &Path) -> Option<Self> {
        Self::open(workdir).ok()
    }

    // Only history walks benefit from the object cache, they re-decode the
    // same commit objects repeatedly; single-object reads open plain.
    pub fn open_cached(workdir: &Path) -> Result<Self> {
        let mut repo = gix::open(workdir)?;
        repo.object_cache_size_if_unset(OBJECT_CACHE_BYTES);
        Ok(Self { inner: repo })
    }

    pub fn init(path: &Path, name: &str, description: &str) -> Result<String> {
        use gix::refs::transaction::{Change, LogChange, PreviousValue, RefEdit, RefLog};

        std::fs::create_dir_all(path)
            .with_context(|| format!("failed to create {}", path.display()))?;

        let repo = gix::init(path)?;

        let (signature, mut time_buf) = Self::repository_signature();
        let signature = signature.to_ref(&mut time_buf);

        // The initial branch is `main` regardless of `init.defaultBranch`:
        // point the unborn HEAD there.
        let head = gix::refs::FullName::try_from("HEAD")
            .map_err(|e| anyhow::anyhow!("invalid ref name: {e}"))?;

        repo.edit_references_as(
            [RefEdit {
                change: Change::Update {
                    log: LogChange {
                        mode: RefLog::AndReference,
                        force_create_reflog: false,
                        message: "checkout: moving to main".into(),
                    },
                    expected: PreviousValue::Any,
                    new: gix::refs::Target::Symbolic(
                        gix::refs::FullName::try_from("refs/heads/main")
                            .map_err(|e| anyhow::anyhow!("invalid ref name: {e}"))?,
                    ),
                },
                name: head,
                deref: false,
            }],
            Some(signature),
        )?;

        let readme = if description.trim().is_empty() {
            format!("# {name}\n")
        } else {
            format!("# {name}\n\n{description}\n")
        };

        std::fs::write(path.join("README.md"), &readme).context("failed to write README.md")?;

        let blob = repo.write_object(gix::objs::Blob {
            data: readme.into_bytes(),
        })?;

        let tree = repo.write_object(gix::objs::Tree {
            entries: vec![gix::objs::tree::Entry {
                mode: gix::objs::tree::EntryKind::Blob.into(),
                filename: gix::bstr::BString::from("README.md"),
                oid: blob.into(),
            }],
        })?;

        let commit = repo.commit_as(
            signature,
            signature,
            "HEAD",
            "Initial commit",
            tree,
            Vec::<gix::ObjectId>::new(),
        )?;

        // Populate the index so the fresh repository is clean, as `git add`
        // and `git commit` would leave it.
        let mut index = repo.index_from_tree(&tree)?;
        index.write(gix::index::write::Options::default())?;

        Ok(commit.to_string())
    }

    // Not kept in any cache, unlike `GitCache::ensure_clone`.
    pub fn clone<U: AsRef<str>>(clone_urls: &[U], path: &Path) -> Result<Self> {
        if path.exists() {
            anyhow::bail!("destination {} already exists", path.display());
        }

        let mut last_error = None;

        for url in clone_urls {
            match Self::clone_from(url.as_ref(), path) {
                Ok(repo) => {
                    // The default-refspec clone misses the `refs/nostr/*` PR refs.
                    repo.fetch().ok();
                    return Ok(repo);
                }
                Err(error) => last_error = Some(error),
            }
        }

        match last_error {
            Some(error) => Err(error).context("failed to clone from any mirror"),
            None => anyhow::bail!("no clone URLs provided"),
        }
    }

    fn clone_from(url: &str, path: &Path) -> Result<Self> {
        let url = Self::transport_url(url);
        let url = gix::url::parse(url).context("invalid clone URL")?;

        let mut prepare = gix::prepare_clone(url, path)?;
        let (mut checkout, _fetch) =
            prepare.fetch_then_checkout(gix::progress::Discard, &gix::interrupt::IS_INTERRUPTED)?;
        let (repo, _checkout) =
            checkout.main_worktree(gix::progress::Discard, &gix::interrupt::IS_INTERRUPTED)?;

        Ok(Self { inner: repo })
    }

    pub fn inner(&self) -> &gix::Repository {
        &self.inner
    }

    pub fn workdir(&self) -> Option<&Path> {
        self.inner.workdir()
    }

    // `None` for an unborn HEAD.
    pub fn head(&self) -> Option<String> {
        self.inner.head_id().ok().map(|id| id.to_string())
    }

    // `Ok(None)` when the revisions share no common ancestor — a valid
    // outcome for a proposal; unresolvable revisions are errors.
    pub fn merge_base(&self, a: &str, b: &str) -> Result<Option<String>> {
        let a = self.inner.rev_parse_single(a.as_bytes())?;
        let b = self.inner.rev_parse_single(b.as_bytes())?;
        match self.inner.merge_base(a, b) {
            Ok(id) => Ok(Some(id.to_string())),
            Err(gix::repository::merge_base::Error::NotFound { .. }) => Ok(None),
            Err(e) => Err(e.into()),
        }
    }

    // Oldest first: the order `git am` creates them.
    pub fn commits_since(&self, base: Option<&str>) -> Result<Vec<String>> {
        let head = match self.inner.head_id() {
            Ok(head) => head,
            Err(_) if base.is_none() => return Ok(Vec::new()),
            Err(e) => return Err(e).context("repository has no commits"),
        };

        let Some(base) = base else {
            return Ok(vec![head.to_string()]);
        };

        let base = self.inner.rev_parse_single(base.as_bytes())?;
        let mut commits = Vec::new();

        for info in self
            .inner
            .rev_walk([head])
            .sorting(gix::revision::walk::Sorting::ByCommitTime(
                gix::traverse::commit::simple::CommitTimeOrder::NewestFirst,
            ))
            .with_hidden([base])
            .all()?
        {
            commits.push(info?.id().to_string());
        }

        commits.reverse();

        Ok(commits)
    }

    // The NIP-34 announcement's `euc` marker; `None` without commits.
    pub fn root_commit(&self) -> Result<Option<String>> {
        let Ok(head) = self.inner.head_id() else {
            return Ok(None);
        };

        for info in self
            .inner
            .rev_walk([head])
            .sorting(gix::revision::walk::Sorting::ByCommitTime(
                gix::traverse::commit::simple::CommitTimeOrder::NewestFirst,
            ))
            .all()?
        {
            let info = info?;
            if info.parent_ids().next().is_none() {
                return Ok(Some(info.id().to_string()));
            }
        }

        Ok(None)
    }

    pub fn refs_with_prefix(&self, prefix: &str) -> Result<Vec<String>> {
        let pattern = prefix.trim_end_matches('/');
        let mut names = Vec::new();

        for reference in self.inner.references()?.all()? {
            let reference = reference.map_err(|error| anyhow::anyhow!("{error}"))?;
            let name = String::from_utf8_lossy(reference.name().as_bstr()).into_owned();

            // Match the pattern itself and everything beneath it.
            let under_pattern = name
                .strip_prefix(pattern)
                .is_some_and(|rest| rest.is_empty() || rest.starts_with('/'));

            if under_pattern {
                names.push(name);
            }
        }

        names.sort();

        Ok(names)
    }

    pub fn delete_refs_with_prefix(&self, prefix: &str) -> Result<()> {
        use gix::refs::transaction::{Change, PreviousValue, RefEdit, RefLog};

        let refs = self.refs_with_prefix(prefix)?;
        if refs.is_empty() {
            return Ok(());
        }

        let edits: Vec<RefEdit> = refs
            .iter()
            .map(|name| {
                let full = gix::refs::FullName::try_from(name.as_str())
                    .map_err(|e| anyhow::anyhow!("invalid ref name {name}: {e}"))?;
                Ok(RefEdit {
                    change: Change::Delete {
                        expected: PreviousValue::Any,
                        log: RefLog::AndReference,
                    },
                    name: full,
                    deref: false,
                })
            })
            .collect::<Result<Vec<_>>>()?;

        self.inner.edit_references(edits)?;

        Ok(())
    }

    pub fn current_branch(&self) -> Option<String> {
        let head = self.inner.head().ok()?;
        let name = head.referent_name()?;
        Some(String::from_utf8_lossy(name.shorten()).into_owned())
    }

    pub fn ref_exists(&self, name: &str) -> bool {
        self.inner.find_reference(name).is_ok()
    }

    pub fn branches(&self) -> Result<Vec<String>> {
        let mut names = Vec::new();
        for reference in self.inner.references()?.local_branches()? {
            let reference = reference.map_err(|error| anyhow::anyhow!("{error}"))?;
            names.push(String::from_utf8_lossy(reference.name().shorten()).into_owned());
        }
        names.sort();
        Ok(names)
    }

    pub fn tags(&self) -> Result<Vec<String>> {
        let mut names = Vec::new();
        for reference in self.inner.references()?.tags()? {
            let reference = reference.map_err(|error| anyhow::anyhow!("{error}"))?;
            names.push(String::from_utf8_lossy(reference.name().shorten()).into_owned());
        }
        names.sort();
        Ok(names)
    }

    pub fn ref_state(&self) -> Result<RepoRefState> {
        let mut refs = Vec::new();

        for reference in self.inner.references()?.local_branches()? {
            let reference = reference.map_err(|error| anyhow::anyhow!("{error}"))?;
            refs.push((
                String::from_utf8_lossy(reference.name().as_bstr()).into_owned(),
                reference.id().to_string(),
            ));
        }

        for reference in self.inner.references()?.tags()? {
            let reference = reference.map_err(|error| anyhow::anyhow!("{error}"))?;
            refs.push((
                String::from_utf8_lossy(reference.name().as_bstr()).into_owned(),
                reference.id().to_string(),
            ));
        }
        refs.sort();

        let head = match self.inner.head() {
            Ok(head) => head
                .referent_name()
                .filter(|name| name.as_bstr().starts_with(b"refs/heads/"))
                .map(|name| String::from_utf8_lossy(name.shorten()).into_owned()),
            Err(_) => None,
        };

        Ok(RepoRefState { refs, head })
    }

    // Fast-forward only: local-only commits or diverged history must never
    // be rewritten by a refresh. Returns whether any branch moved.
    pub fn fast_forward_branches(&self) -> Result<bool> {
        use gix::refs::transaction::{Change, LogChange, PreviousValue, RefEdit, RefLog};

        if self.workdir().is_none() {
            return Ok(false);
        }

        let current = self.current_branch();
        let heads = self.refs_with_prefix("refs/heads")?;

        let (signature, mut time_buf) = Self::repository_signature();
        let signature = signature.to_ref(&mut time_buf);

        let mut moved = false;

        for head in heads {
            let Some(branch) = head.strip_prefix("refs/heads/") else {
                continue;
            };

            let remote = format!("refs/remotes/origin/{branch}");
            let Ok(mut remote_reference) = self.inner.find_reference(&remote) else {
                continue;
            };

            let Ok(mut local_reference) = self.inner.find_reference(&head) else {
                continue;
            };

            let Ok(remote_oid) = remote_reference.peel_to_id() else {
                continue;
            };

            let Ok(local_oid) = local_reference.peel_to_id() else {
                continue;
            };

            let remote_oid = remote_oid.detach();
            let local_oid = local_oid.detach();

            if local_oid == remote_oid {
                continue;
            }

            // Only fast-forward: the base must be the local tip.
            let Ok(base) = self.inner.merge_base(local_oid, remote_oid) else {
                continue;
            };

            if base != local_oid {
                continue;
            }

            let full = gix::refs::FullName::try_from(head.as_str())
                .map_err(|e| anyhow::anyhow!("invalid ref name: {e}"))?;

            let edit = |new: gix::refs::Target| RefEdit {
                change: Change::Update {
                    log: LogChange {
                        mode: RefLog::AndReference,
                        force_create_reflog: false,
                        message: format!("merge {remote}: Fast-forward").into(),
                    },
                    expected: PreviousValue::ExistingMustMatch(gix::refs::Target::Object(
                        local_oid,
                    )),
                    new,
                },
                name: full.clone(),
                deref: false,
            };

            if current.as_deref() == Some(branch) {
                // Only proceed on a clean worktree, like `git merge --ff-only`.
                if self.is_dirty() {
                    continue;
                }

                let tree = self.inner.find_object(remote_oid)?.peel_to_tree()?.id;

                self.force_checkout(&tree)?;

                self.inner.edit_references_as(
                    [edit(gix::refs::Target::Object(remote_oid))],
                    Some(signature),
                )?;

                moved = true;
            } else {
                self.inner.edit_references_as(
                    [edit(gix::refs::Target::Object(remote_oid))],
                    Some(signature),
                )?;

                moved = true;
            }
        }

        Ok(moved)
    }

    // Like `git -c user.name=… -c user.email=…` per invocation: the repository
    // works without a global git identity, and `gix` runs no hooks and never signs.
    pub(crate) fn repository_signature() -> (gix::actor::Signature, gix::date::parse::TimeBuf) {
        let seconds = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .map(|duration| duration.as_secs() as i64)
            .unwrap_or_default();

        let signature = gix::actor::Signature {
            name: gix::bstr::BString::from("Signed"),
            email: gix::bstr::BString::from("signed@localhost"),
            time: gix::date::Time { seconds, offset: 0 },
        };

        (signature, gix::date::parse::TimeBuf::default())
    }

    // GRASP servers announce `grasp://` clone URLs but the transport is git
    // smart HTTP, so the scheme is rewritten for gix.
    pub(crate) fn transport_url(url: &str) -> String {
        url.strip_prefix("grasp://")
            .map(|rest| format!("https://{rest}"))
            .unwrap_or_else(|| url.to_owned())
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RepoRefState {
    pub refs: Vec<(String, String)>,
    pub head: Option<String>,
}