use std::convert::TryFrom;

use crate::parse::parse_signature;
use crate::{Blob, BlobRef, Commit, CommitRef, Object, ObjectRef, Tag, TagRef, Tree, TreeRef, tree};

impl TryFrom<TagRef<'_>> for Tag {
    type Error = crate::decode::Error;

    fn try_from(other: TagRef<'_>) -> Result<Tag, Self::Error> {
        let TagRef {
            target,
            name,
            target_kind,
            message,
            tagger,
            pgp_signature,
        } = other;
        let untrimmed_tagger = tagger.map(parse_signature).transpose()?.map(Into::into);
        Ok(Tag {
            target: gix_hash::ObjectId::from_hex(target).expect("prior parser validation"),
            name: name.to_owned(),
            target_kind,
            message: message.to_owned(),
            tagger: untrimmed_tagger,
            pgp_signature: pgp_signature.map(ToOwned::to_owned),
        })
    }
}

impl TryFrom<CommitRef<'_>> for Commit {
    type Error = crate::decode::Error;

    fn try_from(other: CommitRef<'_>) -> Result<Commit, Self::Error> {
        let CommitRef {
            tree,
            parents,
            author,
            committer,
            encoding,
            message,
            extra_headers,
        } = other;

        let untrimmed_author = parse_signature(author)?;
        let untrimmed_committer = parse_signature(committer)?;
        Ok(Commit {
            tree: gix_hash::ObjectId::from_hex(tree).expect("prior parser validation"),
            parents: parents
                .iter()
                .map(|parent| gix_hash::ObjectId::from_hex(parent).expect("prior parser validation"))
                .collect(),
            author: untrimmed_author.into(),
            committer: untrimmed_committer.into(),
            encoding: encoding.map(ToOwned::to_owned),
            message: message.to_owned(),
            extra_headers: extra_headers
                .into_iter()
                .map(|(k, v)| (k.into(), v.into_owned()))
                .collect(),
        })
    }
}

impl<'a> From<BlobRef<'a>> for Blob {
    fn from(v: BlobRef<'a>) -> Self {
        Blob {
            data: v.data.to_owned(),
        }
    }
}

impl From<TreeRef<'_>> for Tree {
    fn from(other: TreeRef<'_>) -> Tree {
        let TreeRef { entries } = other;
        Tree {
            entries: entries.into_iter().map(Into::into).collect(),
        }
    }
}

impl From<tree::EntryRef<'_>> for tree::Entry {
    fn from(other: tree::EntryRef<'_>) -> tree::Entry {
        let tree::EntryRef { mode, filename, oid } = other;
        tree::Entry {
            mode,
            filename: filename.to_owned(),
            oid: oid.into(),
        }
    }
}

impl<'a> From<&'a tree::Entry> for tree::EntryRef<'a> {
    fn from(other: &'a tree::Entry) -> tree::EntryRef<'a> {
        let tree::Entry { mode, filename, oid } = other;
        tree::EntryRef {
            mode: *mode,
            filename: filename.as_ref(),
            oid,
        }
    }
}

impl TryFrom<ObjectRef<'_>> for Object {
    type Error = crate::decode::Error;

    fn try_from(v: ObjectRef<'_>) -> Result<Self, Self::Error> {
        Ok(match v {
            ObjectRef::Tree(v) => Object::Tree(v.into()),
            ObjectRef::Blob(v) => Object::Blob(v.into()),
            ObjectRef::Commit(v) => Object::Commit(v.try_into()?),
            ObjectRef::Tag(v) => Object::Tag(v.try_into()?),
        })
    }
}

impl From<Tag> for Object {
    fn from(v: Tag) -> Self {
        Object::Tag(v)
    }
}

impl From<Commit> for Object {
    fn from(v: Commit) -> Self {
        Object::Commit(v)
    }
}

impl From<Tree> for Object {
    fn from(v: Tree) -> Self {
        Object::Tree(v)
    }
}

impl From<Blob> for Object {
    fn from(v: Blob) -> Self {
        Object::Blob(v)
    }
}

impl TryFrom<Object> for Tag {
    type Error = Object;

    fn try_from(value: Object) -> Result<Self, Self::Error> {
        Ok(match value {
            Object::Tag(v) => v,
            _ => return Err(value),
        })
    }
}

impl TryFrom<Object> for Commit {
    type Error = Object;

    fn try_from(value: Object) -> Result<Self, Self::Error> {
        Ok(match value {
            Object::Commit(v) => v,
            _ => return Err(value),
        })
    }
}

impl TryFrom<Object> for Tree {
    type Error = Object;

    fn try_from(value: Object) -> Result<Self, Self::Error> {
        Ok(match value {
            Object::Tree(v) => v,
            _ => return Err(value),
        })
    }
}

impl TryFrom<Object> for Blob {
    type Error = Object;

    fn try_from(value: Object) -> Result<Self, Self::Error> {
        Ok(match value {
            Object::Blob(v) => v,
            _ => return Err(value),
        })
    }
}

impl<'a> From<TagRef<'a>> for ObjectRef<'a> {
    fn from(v: TagRef<'a>) -> Self {
        ObjectRef::Tag(v)
    }
}

impl<'a> From<CommitRef<'a>> for ObjectRef<'a> {
    fn from(v: CommitRef<'a>) -> Self {
        ObjectRef::Commit(v)
    }
}

impl<'a> From<TreeRef<'a>> for ObjectRef<'a> {
    fn from(v: TreeRef<'a>) -> Self {
        ObjectRef::Tree(v)
    }
}

impl<'a> From<BlobRef<'a>> for ObjectRef<'a> {
    fn from(v: BlobRef<'a>) -> Self {
        ObjectRef::Blob(v)
    }
}

impl<'a> TryFrom<ObjectRef<'a>> for TagRef<'a> {
    type Error = ObjectRef<'a>;

    fn try_from(value: ObjectRef<'a>) -> Result<Self, Self::Error> {
        Ok(match value {
            ObjectRef::Tag(v) => v,
            _ => return Err(value),
        })
    }
}

impl<'a> TryFrom<ObjectRef<'a>> for CommitRef<'a> {
    type Error = ObjectRef<'a>;

    fn try_from(value: ObjectRef<'a>) -> Result<Self, Self::Error> {
        Ok(match value {
            ObjectRef::Commit(v) => v,
            _ => return Err(value),
        })
    }
}

impl<'a> TryFrom<ObjectRef<'a>> for TreeRef<'a> {
    type Error = ObjectRef<'a>;

    fn try_from(value: ObjectRef<'a>) -> Result<Self, Self::Error> {
        Ok(match value {
            ObjectRef::Tree(v) => v,
            _ => return Err(value),
        })
    }
}

impl<'a> TryFrom<ObjectRef<'a>> for BlobRef<'a> {
    type Error = ObjectRef<'a>;

    fn try_from(value: ObjectRef<'a>) -> Result<Self, Self::Error> {
        Ok(match value {
            ObjectRef::Blob(v) => v,
            _ => return Err(value),
        })
    }
}