use std::ops::DerefMut;

use git_hash::ObjectId;
use git_odb::{Find, FindExt};

use crate::{
    easy,
    easy::{object, ObjectRef},
};

pub fn find_object<A: easy::Access + Sized>(
    access: &A,
    id: impl Into<ObjectId>,
) -> Result<easy::ObjectRef<'_, A>, object::find::existing::Error> {
    let state = access.state();
    let id = id.into();
    let kind = {
        let mut buf = access.state().try_borrow_mut_buf()?;
        let obj = access
            .repo()?
            .odb
            .find(&id, &mut buf, state.try_borrow_mut_pack_cache()?.deref_mut())?;
        obj.kind
    };

    ObjectRef::from_current_buf(id, kind, access).map_err(Into::into)
}

pub fn try_find_object<A: easy::Access + Sized>(
    access: &A,
    id: impl Into<ObjectId>,
) -> Result<Option<easy::ObjectRef<'_, A>>, object::find::Error> {
    let state = access.state();
    let id = id.into();
    access
        .repo()?
        .odb
        .try_find(
            &id,
            state.try_borrow_mut_buf()?.deref_mut(),
            state.try_borrow_mut_pack_cache()?.deref_mut(),
        )?
        .map(|obj| {
            let kind = obj.kind;
            drop(obj);
            ObjectRef::from_current_buf(id, kind, access).map_err(Into::into)
        })
        .transpose()
}

pub trait ObjectAccessExt: easy::Access + Sized {
    // NOTE: in order to get the actual kind of object, is must be fully decoded from storage in case of packs
    // even though partial decoding is possible for loose objects, it won't matter much here.
    fn find_object(&self, id: impl Into<ObjectId>) -> Result<ObjectRef<'_, Self>, object::find::existing::Error> {
        find_object(self, id)
    }

    fn try_find_object(&self, id: impl Into<ObjectId>) -> Result<Option<ObjectRef<'_, Self>>, object::find::Error> {
        try_find_object(self, id)
    }
}