use std::{cell::RefCell, path::PathBuf};

use git_hash::ObjectId;

use crate::easy;

pub(crate) mod ext;

pub mod borrow;
pub mod commit;
pub mod handle;
pub mod head;
pub mod object;
pub mod oid;
pub mod reference;
pub mod tag;

/// The head reference, as created from looking at `.git/HEAD`, able to represent all of its possible states.
///
/// Note that like [`Reference`], this type's data is snapshot of persisted state on disk.
pub struct Head<'repo> {
    /// One of various possible states for the HEAD reference
    pub kind: head::Kind,
    handle: &'repo easy::Handle,
}

/// An [ObjectId] with access to a repository.
#[derive(Clone, Copy)]
pub struct Oid<'r> {
    /// The actual object id
    inner: ObjectId,
    handle: &'r easy::Handle,
}

/// A decoded object with a reference to its owning repository.
///
/// ## Limitations
///
/// Note that it holds a reference to a buffer of it's associated repository handle, so there
/// can only be one at a time, per handle.
pub struct Object<'repo> {
    /// The id of the object
    pub id: ObjectId,
    /// The kind of the object
    pub kind: git_object::Kind,
    /// The fully decoded object data
    pub data: Vec<u8>,
    handle: &'repo easy::Handle,
}

impl<'a> Drop for Object<'a> {
    fn drop(&mut self) {
        self.handle.reuse_buffer(&mut self.data);
    }
}

/// A decoded tree object with access to its owning repository.
///
/// Please note that the limitations described in [Object] apply here as well.
pub struct Tree<'repo> {
    /// The id of the tree
    pub id: ObjectId,
    /// The fully decoded tree data
    pub data: Vec<u8>,
    handle: &'repo easy::Handle,
}

impl<'a> Drop for Tree<'a> {
    fn drop(&mut self) {
        self.handle.reuse_buffer(&mut self.data);
    }
}

/// A decoded commit object with access to its owning repository.
///
/// Please note that the limitations described in [Object] apply here as well.
pub struct Commit<'repo> {
    /// The id of the commit
    pub id: ObjectId,
    /// The fully decoded commit data
    pub data: Vec<u8>,
    handle: &'repo easy::Handle,
}

impl<'a> Drop for Commit<'a> {
    fn drop(&mut self) {
        self.handle.reuse_buffer(&mut self.data);
    }
}

/// A detached, self-contained object, without access to its source repository.
///
/// Use it if an `ObjectRef` should be sent over thread boundaries or stored in collections.
#[derive(Clone)]
pub struct DetachedObject {
    /// The id of the object
    pub id: ObjectId,
    /// The kind of the object
    pub kind: git_object::Kind,
    /// The fully decoded object data
    pub data: Vec<u8>,
}

/// A reference that points to an object or reference, with access to its source repository.
///
/// Note that these are snapshots and won't recognize if they are stale.
pub struct Reference<'r> {
    /// The actual reference data
    pub inner: git_ref::Reference,
    pub(crate) handle: &'r easy::Handle,
}

/// State for use in `Easy*` to provide mutable parts of a repository such as caches and buffers.
///
/// Note that it clones itself so that it is empty, requiring the user to configure each clone separately, specifically
/// and explicitly. This is to have the fastest-possible default configuration available by default, but allow
/// those who experiment with workloads to get speed boosts of 2x or more.
pub struct Handle {
    /// A ref store with shared ownership (or the equivalent of it).
    pub refs: crate::RefStore,
    /// A way to access objects.
    pub objects: crate::OdbHandle,
    work_tree: Option<PathBuf>,
    /// The kind of hash that is used or should be used for object ids
    object_hash: git_hash::Kind,
    /// A free-list of re-usable object backing buffers
    bufs: RefCell<Vec<Vec<u8>>>,
}