use crate::{Blob, ObjectDetached};

///
#[cfg(feature = "blob-diff")]
pub mod diff {
    use std::ops::Range;

    use gix_diff::blob::{platform::prepare_diff::Operation, ResourceKind};

    use crate::{
        bstr::ByteSlice,
        object::{blob::diff::lines::Change, tree::diff::change::Event},
    };

    /// A platform to keep temporary information to perform line diffs on modified blobs.
    ///
    pub struct Platform<'a> {
        /// The cache holding diffable data related to our blobs.
        pub resource_cache: &'a mut gix_diff::blob::Platform,
    }

    ///
    #[allow(clippy::empty_docs)]
    pub mod init {
        /// The error returned by [`Platform::from_tree_change()`][super::Platform::from_tree_change()].
        pub type Error = gix_diff::blob::platform::set_resource::Error;
    }

    impl<'a> Platform<'a> {
        /// Produce a platform for performing various diffs after obtaining the data from a single `tree_change`.
        pub fn from_tree_change(
            tree_change: &crate::object::tree::diff::Change<'_, '_, '_>,
            resource_cache: &'a mut gix_diff::blob::Platform,
        ) -> Result<Platform<'a>, init::Error> {
            match tree_change.event {
                Event::Addition { entry_mode, id } => {
                    resource_cache.set_resource(
                        id.repo.object_hash().null(),
                        entry_mode.kind(),
                        tree_change.location,
                        ResourceKind::OldOrSource,
                        &id.repo.objects,
                    )?;
                    resource_cache.set_resource(
                        id.inner,
                        entry_mode.kind(),
                        tree_change.location,
                        ResourceKind::NewOrDestination,
                        &id.repo.objects,
                    )?;
                }
                Event::Deletion { entry_mode, id } => {
                    resource_cache.set_resource(
                        id.inner,
                        entry_mode.kind(),
                        tree_change.location,
                        ResourceKind::OldOrSource,
                        &id.repo.objects,
                    )?;
                    resource_cache.set_resource(
                        id.repo.object_hash().null(),
                        entry_mode.kind(),
                        tree_change.location,
                        ResourceKind::NewOrDestination,
                        &id.repo.objects,
                    )?;
                }
                Event::Modification {
                    previous_entry_mode,
                    previous_id,
                    entry_mode,
                    id,
                } => {
                    resource_cache.set_resource(
                        previous_id.inner,
                        previous_entry_mode.kind(),
                        tree_change.location,
                        ResourceKind::OldOrSource,
                        &previous_id.repo.objects,
                    )?;
                    resource_cache.set_resource(
                        id.inner,
                        entry_mode.kind(),
                        tree_change.location,
                        ResourceKind::NewOrDestination,
                        &id.repo.objects,
                    )?;
                }
                Event::Rewrite {
                    source_location,
                    source_entry_mode,
                    source_id,
                    entry_mode,
                    id,
                    diff: _,
                    copy: _,
                } => {
                    resource_cache.set_resource(
                        source_id.inner,
                        source_entry_mode.kind(),
                        source_location,
                        ResourceKind::OldOrSource,
                        &source_id.repo.objects,
                    )?;
                    resource_cache.set_resource(
                        id.inner,
                        entry_mode.kind(),
                        tree_change.location,
                        ResourceKind::NewOrDestination,
                        &id.repo.objects,
                    )?;
                }
            }
            Ok(Self { resource_cache })
        }
    }

    ///
    #[allow(clippy::empty_docs)]
    pub mod lines {
        use crate::bstr::BStr;

        /// The error returned by [Platform::lines()](super::Platform::lines()).
        #[derive(Debug, thiserror::Error)]
        #[allow(missing_docs)]
        pub enum Error<E>
        where
            E: std::error::Error + Send + Sync + 'static,
        {
            #[error(transparent)]
            ProcessHunk(E),
            #[error(transparent)]
            PrepareDiff(#[from] gix_diff::blob::platform::prepare_diff::Error),
        }

        /// A change to a hunk of lines.
        pub enum Change<'a, 'data> {
            /// Lines were added.
            Addition {
                /// The lines themselves without terminator.
                lines: &'a [&'data BStr],
            },
            /// Lines were removed.
            Deletion {
                /// The lines themselves without terminator.
                lines: &'a [&'data BStr],
            },
            /// Lines have been replaced.
            Modification {
                /// The replaced lines without terminator.
                lines_before: &'a [&'data BStr],
                /// The new lines without terminator.
                lines_after: &'a [&'data BStr],
            },
        }
    }

    impl<'a> Platform<'a> {
        /// Perform a diff on lines between the old and the new version of a blob, passing each hunk of lines to `process_hunk`.
        /// The diffing algorithm is determined by the `diff.algorithm` configuration, or individual diff drivers.
        /// Note that `process_hunk` is not called if one of the involved resources are binary, but that can be determined
        /// by introspecting the outcome.
        // TODO: more tests (only tested insertion right now)
        pub fn lines<FnH, E>(
            &mut self,
            mut process_hunk: FnH,
        ) -> Result<gix_diff::blob::platform::prepare_diff::Outcome<'_>, lines::Error<E>>
        where
            FnH: FnMut(lines::Change<'_, '_>) -> Result<(), E>,
            E: std::error::Error + Send + Sync + 'static,
        {
            self.resource_cache.options.skip_internal_diff_if_external_is_configured = false;

            let prep = self.resource_cache.prepare_diff()?;
            match prep.operation {
                Operation::InternalDiff { algorithm } => {
                    let input = prep.interned_input();
                    let mut err = None;
                    let mut lines = Vec::new();

                    gix_diff::blob::diff(algorithm, &input, |before: Range<u32>, after: Range<u32>| {
                        if err.is_some() {
                            return;
                        }
                        lines.clear();
                        lines.extend(
                            input.before[before.start as usize..before.end as usize]
                                .iter()
                                .map(|&line| input.interner[line].as_bstr()),
                        );
                        let end_of_before = lines.len();
                        lines.extend(
                            input.after[after.start as usize..after.end as usize]
                                .iter()
                                .map(|&line| input.interner[line].as_bstr()),
                        );
                        let hunk_before = &lines[..end_of_before];
                        let hunk_after = &lines[end_of_before..];
                        if hunk_after.is_empty() {
                            err = process_hunk(Change::Deletion { lines: hunk_before }).err();
                        } else if hunk_before.is_empty() {
                            err = process_hunk(Change::Addition { lines: hunk_after }).err();
                        } else {
                            err = process_hunk(Change::Modification {
                                lines_before: hunk_before,
                                lines_after: hunk_after,
                            })
                            .err();
                        }
                    });

                    if let Some(err) = err {
                        return Err(lines::Error::ProcessHunk(err));
                    }
                }
                Operation::ExternalCommand { .. } => {
                    unreachable!("we disabled that")
                }
                Operation::SourceOrDestinationIsBinary => {}
            };
            Ok(prep)
        }

        /// Count the amount of removed and inserted lines efficiently.
        /// Note that nothing will happen if one of the inputs is binary, and `None` will be returned.
        pub fn line_counts(
            &mut self,
        ) -> Result<Option<gix_diff::blob::sink::Counter<()>>, gix_diff::blob::platform::prepare_diff::Error> {
            self.resource_cache.options.skip_internal_diff_if_external_is_configured = false;

            let prep = self.resource_cache.prepare_diff()?;
            match prep.operation {
                Operation::InternalDiff { algorithm } => {
                    let tokens = prep.interned_input();
                    let counter = gix_diff::blob::diff(algorithm, &tokens, gix_diff::blob::sink::Counter::default());
                    Ok(Some(counter))
                }
                Operation::ExternalCommand { .. } => {
                    unreachable!("we disabled that")
                }
                Operation::SourceOrDestinationIsBinary => Ok(None),
            }
        }
    }
}

/// Remove Lifetime
impl Blob<'_> {
    /// Create an owned instance of this object, copying our data in the process.
    pub fn detached(&self) -> ObjectDetached {
        ObjectDetached {
            id: self.id,
            kind: gix_object::Kind::Blob,
            data: self.data.clone(),
        }
    }

    /// Sever the connection to the `Repository` and turn this instance into a standalone object.
    pub fn detach(self) -> ObjectDetached {
        self.into()
    }

    /// Retrieve this instance's data, leaving its own data empty.
    ///
    /// This method works around the immovability of members of this type.
    pub fn take_data(&mut self) -> Vec<u8> {
        std::mem::take(&mut self.data)
    }
}