//!
use std::convert::TryInto;

use git_hash::ObjectId;
use git_ref::FullNameRef;

use crate::{
    ext::{ObjectIdExt, ReferenceExt},
    Head,
};

/// Represents the kind of `HEAD` reference.
#[derive(Clone)]
pub enum Kind {
    /// The existing reference the symbolic HEAD points to.
    ///
    /// This is the common case.
    Symbolic(git_ref::Reference),
    /// The yet-to-be-created reference the symbolic HEAD refers to.
    ///
    /// This is the case in a newly initialized repository.
    Unborn(git_ref::FullName),
    /// The head points to an object directly, not to a symbolic reference.
    ///
    /// This state is less common and can occur when checking out commits directly.
    Detached {
        /// The object to which the head points to
        target: ObjectId,
        /// Possibly the final destination of `target` after following the object chain from tag objects to commits.
        peeled: Option<ObjectId>,
    },
}

impl Kind {
    /// Attach this instance to a `repo` to produce a [`Head`].
    pub fn attach(self, repo: &crate::Repository) -> Head<'_> {
        Head { kind: self, repo }
    }
}

impl<'repo> Head<'repo> {
    /// Returns the name of this references, always `HEAD`.
    pub fn name(&self) -> &'static FullNameRef {
        // TODO: use a statically checked version of this when available.
        "HEAD".try_into().expect("HEAD is valid")
    }

    /// Returns the full reference name of this head if it is not detached, or `None` otherwise.
    pub fn referent_name(&self) -> Option<&FullNameRef> {
        Some(match &self.kind {
            Kind::Symbolic(r) => r.name.as_ref(),
            Kind::Unborn(name) => name.as_ref(),
            Kind::Detached { .. } => return None,
        })
    }
    /// Returns true if this instance is detached, and points to an object directly.
    pub fn is_detached(&self) -> bool {
        matches!(self.kind, Kind::Detached { .. })
    }

    // TODO: tests
    /// Returns the id the head points to, which isn't possible on unborn heads.
    pub fn id(&self) -> Option<crate::Id<'repo>> {
        match &self.kind {
            Kind::Symbolic(r) => r.target.try_id().map(|oid| oid.to_owned().attach(self.repo)),
            Kind::Detached { peeled, target } => {
                (*peeled).unwrap_or_else(|| target.to_owned()).attach(self.repo).into()
            }
            Kind::Unborn(_) => None,
        }
    }

    /// Try to transform this instance into the symbolic reference that it points to, or return `None` if head is detached or unborn.
    pub fn try_into_referent(self) -> Option<crate::Reference<'repo>> {
        match self.kind {
            Kind::Symbolic(r) => r.attach(self.repo).into(),
            _ => None,
        }
    }
}
///
pub mod log {
    use std::convert::TryInto;

    use git_hash::ObjectId;

    use crate::{
        bstr::{BString, ByteSlice},
        Head,
    };

    impl<'repo> Head<'repo> {
        /// Return a platform for obtaining iterators on the reference log associated with the `HEAD` reference.
        pub fn log_iter(&self) -> git_ref::file::log::iter::Platform<'static, 'repo> {
            git_ref::file::log::iter::Platform {
                store: &self.repo.refs,
                name: "HEAD".try_into().expect("HEAD is always valid"),
                buf: Vec::new(),
            }
        }

        /// Return a list of all branch names that were previously checked out with the first-ever checked out branch
        /// being the first entry of the list, and the most recent is the last, along with the commit they were pointing to
        /// at the time.
        pub fn prior_checked_out_branches(&self) -> std::io::Result<Option<Vec<(BString, ObjectId)>>> {
            Ok(self.log_iter().all()?.map(|log| {
                log.filter_map(Result::ok)
                    .filter_map(|line| {
                        line.message
                            .strip_prefix(b"checkout: moving from ")
                            .and_then(|from_to| from_to.find(" to ").map(|pos| &from_to[..pos]))
                            .map(|from_branch| (from_branch.as_bstr().to_owned(), line.previous_oid()))
                    })
                    .collect()
            }))
        }
    }
}

///
pub mod peel {
    use crate::{
        ext::{ObjectIdExt, ReferenceExt},
        Head,
    };

    mod error {
        use crate::{object, reference};

        /// The error returned by [Head::peel_to_id_in_place()][super::Head::peel_to_id_in_place()] and [Head::into_fully_peeled_id()][super::Head::into_fully_peeled_id()].
        #[derive(Debug, thiserror::Error)]
        #[allow(missing_docs)]
        pub enum Error {
            #[error(transparent)]
            FindExistingObject(#[from] object::find::existing::OdbError),
            #[error(transparent)]
            PeelReference(#[from] reference::peel::Error),
        }
    }
    pub use error::Error;

    use crate::head::Kind;

    ///
    pub mod to_commit {
        use crate::object;

        /// The error returned by [Head::peel_to_commit_in_place()][super::Head::peel_to_commit_in_place()].
        #[derive(Debug, thiserror::Error)]
        #[allow(missing_docs)]
        pub enum Error {
            #[error(transparent)]
            Peel(#[from] super::Error),
            #[error("Branch '{name}' does not have any commits")]
            Unborn { name: git_ref::FullName },
            #[error(transparent)]
            ObjectKind(#[from] object::try_into::Error),
        }
    }

    impl<'repo> Head<'repo> {
        // TODO: tests
        /// Peel this instance to make obtaining its final target id possible, while returning an error on unborn heads.
        pub fn peeled(mut self) -> Result<Self, Error> {
            self.peel_to_id_in_place().transpose()?;
            Ok(self)
        }

        // TODO: tests
        /// Follow the symbolic reference of this head until its target object and peel it by following tag objects until there is no
        /// more object to follow, and return that object id.
        ///
        /// Returns `None` if the head is unborn.
        pub fn peel_to_id_in_place(&mut self) -> Option<Result<crate::Id<'repo>, Error>> {
            Some(match &mut self.kind {
                Kind::Unborn(_name) => return None,
                Kind::Detached {
                    peeled: Some(peeled), ..
                } => Ok((*peeled).attach(self.repo)),
                Kind::Detached { peeled: None, target } => {
                    match target
                        .attach(self.repo)
                        .object()
                        .map_err(Into::into)
                        .and_then(|obj| obj.peel_tags_to_end().map_err(Into::into))
                        .map(|peeled| peeled.id)
                    {
                        Ok(peeled) => {
                            self.kind = Kind::Detached {
                                peeled: Some(peeled),
                                target: *target,
                            };
                            Ok(peeled.attach(self.repo))
                        }
                        Err(err) => Err(err),
                    }
                }
                Kind::Symbolic(r) => {
                    let mut nr = r.clone().attach(self.repo);
                    let peeled = nr.peel_to_id_in_place().map_err(Into::into);
                    *r = nr.detach();
                    peeled
                }
            })
        }

        // TODO: tests
        // TODO: something similar in `crate::Reference`
        /// Follow the symbolic reference of this head until its target object and peel it by following tag objects until there is no
        /// more object to follow, transform the id into a commit if possible and return that.
        ///
        /// Returns an error if the head is unborn or if it doesn't point to a commit.
        pub fn peel_to_commit_in_place(&mut self) -> Result<crate::Commit<'repo>, to_commit::Error> {
            let id = self.peel_to_id_in_place().ok_or_else(|| to_commit::Error::Unborn {
                name: self.referent_name().expect("unborn").to_owned(),
            })??;
            id.object()
                .map_err(|err| to_commit::Error::Peel(Error::FindExistingObject(err)))
                .and_then(|object| object.try_into_commit().map_err(Into::into))
        }

        /// Consume this instance and transform it into the final object that it points to, or `None` if the `HEAD`
        /// reference is yet to be born.
        pub fn into_fully_peeled_id(self) -> Option<Result<crate::Id<'repo>, Error>> {
            Some(match self.kind {
                Kind::Unborn(_name) => return None,
                Kind::Detached {
                    peeled: Some(peeled), ..
                } => Ok(peeled.attach(self.repo)),
                Kind::Detached { peeled: None, target } => target
                    .attach(self.repo)
                    .object()
                    .map_err(Into::into)
                    .and_then(|obj| obj.peel_tags_to_end().map_err(Into::into))
                    .map(|obj| obj.id.attach(self.repo)),
                Kind::Symbolic(r) => r.attach(self.repo).peel_to_id_in_place().map_err(Into::into),
            })
        }
    }
}