//! This crate provides the [`Repository`] abstraction which serves as a hub into all the functionality of git.
//!
//! It's powerful and won't sacrifice performance while still increasing convenience compared to using the sub-crates
//! individually. Sometimes it may hide complexity under the assumption that the performance difference doesn't matter
//! for all but the fewest tools out there, which would be using the underlying crates directly or file an issue.
//!
//! # The prelude and extensions
//!
//! With `use git_repository::prelude::*` you should be ready to go as it pulls in various extension traits to make functionality
//! available on objects that may use it.
//!
//! The method signatures are still complex and may require various arguments for configuration and cache control.
//!
//! ## Easy-Mode
//!
//! Most extensions to existing objects provide an `obj_with_extension.easy(&repo).an_easier_version_of_a_method()` or `easy(&repo)`
//! method to hide all complex arguments and sacrifice some performance for a lot of convenience.
//!
//! When starting out, use `easy(…)` and migrate to the more detailed method signatures to squeeze out more performance.
//!
//! # Cargo-features
//!
//! ## One-stop-shop
//!
//! To make using  _sub-crates_ easier these are re-exported into the root of this crate.
//!
//! `git_repository::`
//! * [`hash`]
//! * [`url`]
//! * [`actor`]
//! * [`object`]
//!   * [`bstr`][object::bstr]
//! * [`odb`]
//!   * [`pack`][odb::pack]
//! * [`refs`]
//! * [`interrupt`]
//! * [`tempfile`]
//! * [`traverse`]
//! * [`diff`]
//! * [`Progress`]
//! * [`progress`]
//! * [`interrupt`]
//! * [`protocol`]
//!   * [`transport`][protocol::transport]
//!
#![deny(unsafe_code, rust_2018_idioms)]
#![allow(missing_docs, unused)]

use crate::hash::ObjectId;
use std::{cell::RefCell, path::PathBuf, rc::Rc, sync::Arc};

// Re-exports to make this a potential one-stop shop crate avoiding people from having to reference various crates themselves.
// This also means that their major version changes affect our major version, but that's alright as we directly expose their
// APIs/instances anyway.
pub use git_actor as actor;
#[cfg(feature = "git-diff")]
pub use git_diff as diff;
pub use git_features::{parallel, progress, progress::Progress};
pub use git_hash as hash;
pub use git_object as object;
pub use git_odb as odb;
#[cfg(feature = "git-protocol")]
pub use git_protocol as protocol;
pub use git_ref as refs;
pub use git_tempfile as tempfile;
#[cfg(feature = "git-traverse")]
pub use git_traverse as traverse;
#[cfg(feature = "git-url")]
pub use git_url as url;

pub mod interrupt;

#[cfg(feature = "git-traverse")]
pub mod ext;
pub mod prelude {
    pub use git_features::parallel::reduce::Finalize;
    pub use git_odb::{Find, FindExt, Write};

    #[cfg(all(feature = "git-traverse"))]
    pub use crate::ext::*;
    pub use crate::reference::ReferencesExt;
}

pub mod init;

pub mod path;
pub use path::Path;

pub mod repository;

pub struct Repository {
    pub refs: git_ref::file::Store,
    pub odb: git_odb::linked::Store,
    pub working_tree: Option<PathBuf>,
}

mod handles {
    use std::{cell::RefCell, rc::Rc, sync::Arc};

    use crate::{Cache, Repository};

    pub struct Shared {
        pub repo: Rc<Repository>,
        pub cache: RefCell<Cache>,
    }

    /// A handle is what threaded programs would use to have thread-local but otherwise shared versions the same `Repository`.
    ///
    /// Mutable data present in the `Handle` itself while keeping the parent `Repository` (which has its own cache) shared.
    /// Otherwise handles reflect the API of a `Repository`.
    pub struct SharedArc {
        pub repo: Arc<Repository>,
        pub cache: RefCell<Cache>,
    }

    impl Clone for Shared {
        fn clone(&self) -> Self {
            Shared {
                repo: Rc::clone(&self.repo),
                cache: RefCell::new(Default::default()),
            }
        }
    }

    impl Clone for SharedArc {
        fn clone(&self) -> Self {
            SharedArc {
                repo: Arc::clone(&self.repo),
                cache: RefCell::new(Default::default()),
            }
        }
    }

    impl From<Repository> for Shared {
        fn from(repo: Repository) -> Self {
            Shared {
                repo: Rc::new(repo),
                cache: RefCell::new(Default::default()),
            }
        }
    }

    impl From<Repository> for SharedArc {
        fn from(repo: Repository) -> Self {
            SharedArc {
                repo: Arc::new(repo),
                cache: RefCell::new(Default::default()),
            }
        }
    }

    impl Repository {
        pub fn into_shared(self) -> Shared {
            self.into()
        }

        pub fn into_shared_arc(self) -> SharedArc {
            self.into()
        }
    }
}
pub use handles::{Shared, SharedArc};

#[derive(Default)]
pub struct Cache {
    packed_refs: Option<refs::packed::Buffer>,
    pub pack: odb::pack::cache::Never, // TODO: choose great alround cache
    pub buf: Vec<u8>,
}

mod traits {
    use std::cell::RefMut;

    use crate::{Cache, Repository, Shared, SharedArc};

    pub trait Access {
        fn repo(&self) -> &Repository;
        fn cache_mut(&self) -> RefMut<'_, Cache>;
    }

    impl Access for Shared {
        fn repo(&self) -> &Repository {
            self.repo.as_ref()
        }

        fn cache_mut(&self) -> RefMut<'_, Cache> {
            self.cache.borrow_mut()
        }
    }

    impl Access for SharedArc {
        fn repo(&self) -> &Repository {
            self.repo.as_ref()
        }

        fn cache_mut(&self) -> RefMut<'_, Cache> {
            self.cache.borrow_mut()
        }
    }
}
pub use traits::Access;

mod cache {
    use crate::{
        refs::{file, packed},
        Cache,
    };

    impl Cache {
        pub fn packed_refs(
            &mut self,
            file: &file::Store,
        ) -> Result<Option<&packed::Buffer>, packed::buffer::open::Error> {
            match self.packed_refs {
                Some(ref packed) => Ok(Some(packed)),
                None => {
                    self.packed_refs = file.packed()?;
                    Ok(self.packed_refs.as_ref())
                }
            }
        }
    }
}

pub struct Object<'r, A> {
    id: ObjectId,
    // data: odb::pack::data::Object<'a>,
    access: &'r A,
}

pub struct Reference<'r, A> {
    pub(crate) backing: Option<reference::Backing>,
    pub(crate) access: &'r A,
}

pub mod reference {
    use std::cell::RefCell;

    use git_hash::ObjectId;

    use crate::{refs, refs::mutable, Access, Object, Reference, Repository};

    pub(crate) enum Backing {
        OwnedPacked {
            /// The validated full name of the reference.
            name: mutable::FullName,
            /// The target object id of the reference, hex encoded.
            target: ObjectId,
            /// The fully peeled object id, hex encoded, that the ref is ultimately pointing to
            /// i.e. when all indirections are removed.
            object: Option<ObjectId>,
        },
        LooseFile(refs::file::loose::Reference),
    }

    pub mod peel_to_id_in_place {
        use quick_error::quick_error;

        use crate::refs;

        quick_error! {
            #[derive(Debug)]
            pub enum Error {
                LoosePeelToId(err: refs::file::loose::reference::peel::to_id::Error) {
                    display("Could not peel loose reference")
                    from()
                    source(err)
                }
                PackedRefsOpen(err: refs::packed::buffer::open::Error) {
                    display("The packed-refs file could not be opened")
                    from()
                    source(err)
                }
            }
        }
    }

    impl<'r, A> Reference<'r, A>
    where
        A: Access + Sized,
    {
        pub fn peel_to_id_in_place(&mut self) -> Result<Object<'r, A>, peel_to_id_in_place::Error> {
            let repo = self.access.repo();
            match &mut self.backing.take().expect("a ref must be set") {
                Backing::LooseFile(r) => {
                    let oid = r.peel_to_id_in_place(
                        &repo.refs,
                        self.access.cache_mut().packed_refs(&repo.refs)?,
                        |oid, buf| {
                            repo.odb
                                .find(oid, buf, &mut self.access.cache_mut().pack)
                                .map(|po| po.map(|o| (o.kind, o.data)))
                        },
                    )?;
                    todo!("loose peeling")
                }
                Backing::OwnedPacked { name, target, object } => {
                    todo!("packed peeling")
                }
            }
        }
    }

    mod access {
        use std::{cell::RefCell, convert::TryInto};

        use crate::{
            hash::ObjectId,
            reference::Backing,
            refs,
            refs::{file::find::Error, PartialName},
            Access, Reference, Repository,
        };

        /// Obtain and alter references comfortably
        pub trait ReferencesExt: Access + Sized {
            fn find_reference<'a, Name, E>(
                &self,
                name: Name,
            ) -> Result<Option<Reference<'_, Self>>, crate::reference::find::Error>
            where
                Name: TryInto<PartialName<'a>, Error = E>,
                Error: From<E>,
            {
                match self
                    .repo()
                    .refs
                    .find(name, self.cache_mut().packed_refs(&self.repo().refs)?)
                {
                    Ok(r) => match r {
                        Some(r) => Ok(Some(Reference {
                            backing: match r {
                                refs::file::Reference::Packed(p) => Backing::OwnedPacked {
                                    name: p.name.into(),
                                    target: p.target(),
                                    object: p
                                        .object
                                        .map(|hex| ObjectId::from_hex(hex).expect("a hash kind we know")),
                                },
                                refs::file::Reference::Loose(l) => Backing::LooseFile(l),
                            }
                            .into(),
                            access: self,
                        })),
                        None => Ok(None),
                    },
                    Err(err) => Err(err.into()),
                }
            }
        }

        impl<A> ReferencesExt for A where A: Access + Sized {}
    }
    use crate::odb::Find;
    pub use access::ReferencesExt;

    pub mod find {
        use quick_error::quick_error;

        use crate::refs;

        quick_error! {
            #[derive(Debug)]
            pub enum Error {
                Find(err: refs::file::find::Error) {
                    display("An error occurred when trying to find a reference")
                    from()
                    source(err)
                }
                PackedRefsOpen(err: refs::packed::buffer::open::Error) {
                    display("The packed-refs file could not be opened")
                    from()
                    source(err)
                }
            }
        }
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum Kind {
    Bare,
    WorkingTree,
}

impl Kind {
    pub fn is_bare(&self) -> bool {
        matches!(self, Kind::Bare)
    }
}

pub fn discover(directory: impl AsRef<std::path::Path>) -> Result<Repository, repository::discover::Error> {
    Repository::discover(directory)
}