use std::borrow::Cow;

use bstr::BStr;
use gix_object::tree;

use crate::{
    index::{Change, ChangeRef},
    rewrites,
    rewrites::tracker::ChangeKind,
    tree::visit::Relation,
};

impl ChangeRef<'_, '_> {
    /// Copy everything into an owned version of this instance.
    pub fn into_owned(self) -> Change {
        match self {
            ChangeRef::Addition {
                location,
                index,
                entry_mode,
                id,
            } => ChangeRef::Addition {
                location: Cow::Owned(location.into_owned()),
                index,
                entry_mode,
                id: Cow::Owned(id.into_owned()),
            },
            ChangeRef::Deletion {
                location,
                index,
                entry_mode,
                id,
            } => ChangeRef::Deletion {
                location: Cow::Owned(location.into_owned()),
                index,
                entry_mode,
                id: Cow::Owned(id.into_owned()),
            },
            ChangeRef::Modification {
                location,
                previous_index,
                previous_entry_mode,
                previous_id,
                index,
                entry_mode,
                id,
            } => ChangeRef::Modification {
                location: Cow::Owned(location.into_owned()),
                previous_index,
                previous_entry_mode,
                previous_id: Cow::Owned(previous_id.into_owned()),
                index,
                entry_mode,
                id: Cow::Owned(id.into_owned()),
            },
            ChangeRef::Rewrite {
                source_location,
                source_index,
                source_entry_mode,
                source_id,
                location,
                index,
                entry_mode,
                id,
                copy,
            } => ChangeRef::Rewrite {
                source_location: Cow::Owned(source_location.into_owned()),
                source_index,
                source_entry_mode,
                source_id: Cow::Owned(source_id.into_owned()),
                location: Cow::Owned(location.into_owned()),
                index,
                entry_mode,
                id: Cow::Owned(id.into_owned()),
                copy,
            },
        }
    }
}

impl ChangeRef<'_, '_> {
    /// Return all shared fields among all variants: `(location, index, entry_mode, id)`
    ///
    /// In case of rewrites, the fields return to the current change.
    ///
    /// Note that there are also more specific accessors in case you only need to access to one of
    /// these fields individually.
    ///
    /// See [`ChangeRef::location()`], [`ChangeRef::index()`], [`ChangeRef::entry_mode()`] and
    /// [`ChangeRef::id()`].
    pub fn fields(&self) -> (&BStr, usize, gix_index::entry::Mode, &gix_hash::oid) {
        match self {
            ChangeRef::Addition {
                location,
                index,
                entry_mode,
                id,
                ..
            }
            | ChangeRef::Deletion {
                location,
                index,
                entry_mode,
                id,
                ..
            }
            | ChangeRef::Modification {
                location,
                index,
                entry_mode,
                id,
                ..
            }
            | ChangeRef::Rewrite {
                location,
                index,
                entry_mode,
                id,
                ..
            } => (location.as_ref(), *index, *entry_mode, id),
        }
    }

    /// Return the `location`, in the case of rewrites referring to the current change.
    pub fn location(&self) -> &BStr {
        match self {
            ChangeRef::Addition { location, .. }
            | ChangeRef::Deletion { location, .. }
            | ChangeRef::Modification { location, .. }
            | ChangeRef::Rewrite { location, .. } => location.as_ref(),
        }
    }

    /// Return the `index`, in the case of rewrites referring to the current change.
    pub fn index(&self) -> usize {
        match self {
            ChangeRef::Addition { index, .. }
            | ChangeRef::Deletion { index, .. }
            | ChangeRef::Modification { index, .. }
            | ChangeRef::Rewrite { index, .. } => *index,
        }
    }

    /// Return the `entry_mode`, in the case of rewrites referring to the current change.
    pub fn entry_mode(&self) -> gix_index::entry::Mode {
        match self {
            ChangeRef::Addition { entry_mode, .. }
            | ChangeRef::Deletion { entry_mode, .. }
            | ChangeRef::Modification { entry_mode, .. }
            | ChangeRef::Rewrite { entry_mode, .. } => *entry_mode,
        }
    }

    /// Return the `id`, in the case of rewrites referring to the current change.
    pub fn id(&self) -> &gix_hash::oid {
        match self {
            ChangeRef::Addition { id, .. }
            | ChangeRef::Deletion { id, .. }
            | ChangeRef::Modification { id, .. }
            | ChangeRef::Rewrite { id, .. } => id,
        }
    }
}

impl rewrites::tracker::Change for ChangeRef<'_, '_> {
    fn id(&self) -> &gix_hash::oid {
        match self {
            ChangeRef::Addition { id, .. } | ChangeRef::Deletion { id, .. } | ChangeRef::Modification { id, .. } => {
                id.as_ref()
            }
            ChangeRef::Rewrite { .. } => {
                unreachable!("BUG")
            }
        }
    }

    fn relation(&self) -> Option<Relation> {
        None
    }

    fn kind(&self) -> ChangeKind {
        match self {
            ChangeRef::Addition { .. } => ChangeKind::Addition,
            ChangeRef::Deletion { .. } => ChangeKind::Deletion,
            ChangeRef::Modification { .. } => ChangeKind::Modification,
            ChangeRef::Rewrite { .. } => {
                unreachable!("BUG: rewrites can't be determined ahead of time")
            }
        }
    }

    fn entry_mode(&self) -> tree::EntryMode {
        match self {
            ChangeRef::Addition { entry_mode, .. }
            | ChangeRef::Deletion { entry_mode, .. }
            | ChangeRef::Modification { entry_mode, .. }
            | ChangeRef::Rewrite { entry_mode, .. } => {
                entry_mode
                    .to_tree_entry_mode()
                    // Default is for the impossible case - just don't let it participate in rename tracking.
                    .unwrap_or(tree::EntryKind::Tree.into())
            }
        }
    }

    fn id_and_entry_mode(&self) -> (&gix_hash::oid, tree::EntryMode) {
        match self {
            ChangeRef::Addition { id, entry_mode, .. }
            | ChangeRef::Deletion { id, entry_mode, .. }
            | ChangeRef::Modification { id, entry_mode, .. }
            | ChangeRef::Rewrite { id, entry_mode, .. } => {
                (
                    id,
                    entry_mode
                        .to_tree_entry_mode()
                        // Default is for the impossible case - just don't let it participate in rename tracking.
                        .unwrap_or(tree::EntryKind::Tree.into()),
                )
            }
        }
    }
}