use futures::{channel::oneshot, future::OptionFuture};
use git2::{DiffLineType as GitDiffLineType, DiffOptions as GitOptions, Patch as GitPatch};
use gpui::{App, AsyncApp, Context, Entity, EventEmitter};
use language::{Language, LanguageRegistry};
use rope::Rope;
use std::{cmp, future::Future, iter, ops::Range, sync::Arc};
use sum_tree::SumTree;
use text::{Anchor, Bias, BufferId, OffsetRangeExt, Point};
use util::ResultExt;

pub struct BufferDiff {
    pub buffer_id: BufferId,
    inner: BufferDiffInner,
    secondary_diff: Option<Entity<BufferDiff>>,
}

#[derive(Clone)]
pub struct BufferDiffSnapshot {
    inner: BufferDiffInner,
    secondary_diff: Option<Box<BufferDiffSnapshot>>,
}

#[derive(Clone)]
struct BufferDiffInner {
    hunks: SumTree<InternalDiffHunk>,
    base_text: Option<language::BufferSnapshot>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum DiffHunkStatus {
    Added(DiffHunkSecondaryStatus),
    Modified(DiffHunkSecondaryStatus),
    Removed(DiffHunkSecondaryStatus),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum DiffHunkSecondaryStatus {
    HasSecondaryHunk,
    OverlapsWithSecondaryHunk,
    None,
}

// to stage a hunk:
// - assume hunk starts out as not staged
// - hunk exists with the same buffer range in the unstaged diff and the uncommitted diff
// - we want to construct a "version" of the file that
//   - starts from the index base text
//   - has the single hunk applied to it
//     - the hunk is the one from the UNSTAGED diff, so that the diff base offset range is correct to apply to that diff base
// - write that new version of the file into the index

// to unstage a hunk
// - no hunk in the unstaged diff intersects this hunk from the uncommitted diff
// - we want to compute the hunk that
//   - we can apply to the index text
//   - at the end of applying it,

/// A diff hunk resolved to rows in the buffer.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DiffHunk {
    /// The buffer range, expressed in terms of rows.
    pub row_range: Range<u32>,
    /// The range in the buffer to which this hunk corresponds.
    pub buffer_range: Range<Anchor>,
    /// The range in the buffer's diff base text to which this hunk corresponds.
    pub diff_base_byte_range: Range<usize>,
    pub secondary_status: DiffHunkSecondaryStatus,
}

/// We store [`InternalDiffHunk`]s internally so we don't need to store the additional row range.
#[derive(Debug, Clone, PartialEq, Eq)]
struct InternalDiffHunk {
    buffer_range: Range<Anchor>,
    diff_base_byte_range: Range<usize>,
}

impl sum_tree::Item for InternalDiffHunk {
    type Summary = DiffHunkSummary;

    fn summary(&self, _cx: &text::BufferSnapshot) -> Self::Summary {
        DiffHunkSummary {
            buffer_range: self.buffer_range.clone(),
        }
    }
}

#[derive(Debug, Default, Clone)]
pub struct DiffHunkSummary {
    buffer_range: Range<Anchor>,
}

impl sum_tree::Summary for DiffHunkSummary {
    type Context = text::BufferSnapshot;

    fn zero(_cx: &Self::Context) -> Self {
        Default::default()
    }

    fn add_summary(&mut self, other: &Self, buffer: &Self::Context) {
        self.buffer_range.start = self
            .buffer_range
            .start
            .min(&other.buffer_range.start, buffer);
        self.buffer_range.end = self.buffer_range.end.max(&other.buffer_range.end, buffer);
    }
}

impl<'a> sum_tree::SeekTarget<'a, DiffHunkSummary, DiffHunkSummary> for Anchor {
    fn cmp(
        &self,
        cursor_location: &DiffHunkSummary,
        buffer: &text::BufferSnapshot,
    ) -> cmp::Ordering {
        self.cmp(&cursor_location.buffer_range.end, buffer)
    }
}

impl std::fmt::Debug for BufferDiffInner {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("BufferDiffSnapshot")
            .field("hunks", &self.hunks)
            .finish()
    }
}

impl BufferDiffSnapshot {
    pub fn is_empty(&self) -> bool {
        self.inner.hunks.is_empty()
    }

    pub fn secondary_diff(&self) -> Option<&BufferDiffSnapshot> {
        self.secondary_diff.as_deref()
    }

    pub fn hunks_intersecting_range<'a>(
        &'a self,
        range: Range<Anchor>,
        buffer: &'a text::BufferSnapshot,
    ) -> impl 'a + Iterator<Item = DiffHunk> {
        let unstaged_counterpart = self.secondary_diff.as_ref().map(|diff| &diff.inner);
        self.inner
            .hunks_intersecting_range(range, buffer, unstaged_counterpart)
    }

    pub fn hunks_intersecting_range_rev<'a>(
        &'a self,
        range: Range<Anchor>,
        buffer: &'a text::BufferSnapshot,
    ) -> impl 'a + Iterator<Item = DiffHunk> {
        self.inner.hunks_intersecting_range_rev(range, buffer)
    }

    pub fn base_text(&self) -> Option<&language::BufferSnapshot> {
        self.inner.base_text.as_ref()
    }

    pub fn base_texts_eq(&self, other: &Self) -> bool {
        match (other.base_text(), self.base_text()) {
            (None, None) => true,
            (None, Some(_)) => false,
            (Some(_), None) => false,
            (Some(old), Some(new)) => {
                let (old_id, old_empty) = (old.remote_id(), old.is_empty());
                let (new_id, new_empty) = (new.remote_id(), new.is_empty());
                new_id == old_id || (new_empty && old_empty)
            }
        }
    }
}

impl BufferDiffInner {
    fn hunks_intersecting_range<'a>(
        &'a self,
        range: Range<Anchor>,
        buffer: &'a text::BufferSnapshot,
        secondary: Option<&'a Self>,
    ) -> impl 'a + Iterator<Item = DiffHunk> {
        let range = range.to_offset(buffer);

        let mut cursor = self
            .hunks
            .filter::<_, DiffHunkSummary>(buffer, move |summary| {
                let summary_range = summary.buffer_range.to_offset(buffer);
                let before_start = summary_range.end < range.start;
                let after_end = summary_range.start > range.end;
                !before_start && !after_end
            });

        let anchor_iter = iter::from_fn(move || {
            cursor.next(buffer);
            cursor.item()
        })
        .flat_map(move |hunk| {
            [
                (
                    &hunk.buffer_range.start,
                    (hunk.buffer_range.start, hunk.diff_base_byte_range.start),
                ),
                (
                    &hunk.buffer_range.end,
                    (hunk.buffer_range.end, hunk.diff_base_byte_range.end),
                ),
            ]
        });

        let mut secondary_cursor = secondary.as_ref().map(|diff| {
            let mut cursor = diff.hunks.cursor::<DiffHunkSummary>(buffer);
            cursor.next(buffer);
            cursor
        });

        let mut summaries = buffer.summaries_for_anchors_with_payload::<Point, _, _>(anchor_iter);
        iter::from_fn(move || loop {
            let (start_point, (start_anchor, start_base)) = summaries.next()?;
            let (mut end_point, (mut end_anchor, end_base)) = summaries.next()?;

            if !start_anchor.is_valid(buffer) {
                continue;
            }

            if end_point.column > 0 {
                end_point.row += 1;
                end_point.column = 0;
                end_anchor = buffer.anchor_before(end_point);
            }

            let mut secondary_status = DiffHunkSecondaryStatus::None;
            if let Some(secondary_cursor) = secondary_cursor.as_mut() {
                if start_anchor
                    .cmp(&secondary_cursor.start().buffer_range.start, buffer)
                    .is_gt()
                {
                    secondary_cursor.seek_forward(&end_anchor, Bias::Left, buffer);
                }

                if let Some(secondary_hunk) = secondary_cursor.item() {
                    let secondary_range = secondary_hunk.buffer_range.to_point(buffer);
                    if secondary_range == (start_point..end_point) {
                        secondary_status = DiffHunkSecondaryStatus::HasSecondaryHunk;
                    } else if secondary_range.start <= end_point {
                        secondary_status = DiffHunkSecondaryStatus::OverlapsWithSecondaryHunk;
                    }
                }
            }

            return Some(DiffHunk {
                row_range: start_point.row..end_point.row,
                diff_base_byte_range: start_base..end_base,
                buffer_range: start_anchor..end_anchor,
                secondary_status,
            });
        })
    }

    fn hunks_intersecting_range_rev<'a>(
        &'a self,
        range: Range<Anchor>,
        buffer: &'a text::BufferSnapshot,
    ) -> impl 'a + Iterator<Item = DiffHunk> {
        let mut cursor = self
            .hunks
            .filter::<_, DiffHunkSummary>(buffer, move |summary| {
                let before_start = summary.buffer_range.end.cmp(&range.start, buffer).is_lt();
                let after_end = summary.buffer_range.start.cmp(&range.end, buffer).is_gt();
                !before_start && !after_end
            });

        iter::from_fn(move || {
            cursor.prev(buffer);

            let hunk = cursor.item()?;
            let range = hunk.buffer_range.to_point(buffer);
            let end_row = if range.end.column > 0 {
                range.end.row + 1
            } else {
                range.end.row
            };

            Some(DiffHunk {
                row_range: range.start.row..end_row,
                diff_base_byte_range: hunk.diff_base_byte_range.clone(),
                buffer_range: hunk.buffer_range.clone(),
                // The secondary status is not used by callers of this method.
                secondary_status: DiffHunkSecondaryStatus::None,
            })
        })
    }

    fn compare(&self, old: &Self, new_snapshot: &text::BufferSnapshot) -> Option<Range<Anchor>> {
        let mut new_cursor = self.hunks.cursor::<()>(new_snapshot);
        let mut old_cursor = old.hunks.cursor::<()>(new_snapshot);
        old_cursor.next(new_snapshot);
        new_cursor.next(new_snapshot);
        let mut start = None;
        let mut end = None;

        loop {
            match (new_cursor.item(), old_cursor.item()) {
                (Some(new_hunk), Some(old_hunk)) => {
                    match new_hunk
                        .buffer_range
                        .start
                        .cmp(&old_hunk.buffer_range.start, new_snapshot)
                    {
                        cmp::Ordering::Less => {
                            start.get_or_insert(new_hunk.buffer_range.start);
                            end.replace(new_hunk.buffer_range.end);
                            new_cursor.next(new_snapshot);
                        }
                        cmp::Ordering::Equal => {
                            if new_hunk != old_hunk {
                                start.get_or_insert(new_hunk.buffer_range.start);
                                if old_hunk
                                    .buffer_range
                                    .end
                                    .cmp(&new_hunk.buffer_range.end, new_snapshot)
                                    .is_ge()
                                {
                                    end.replace(old_hunk.buffer_range.end);
                                } else {
                                    end.replace(new_hunk.buffer_range.end);
                                }
                            }

                            new_cursor.next(new_snapshot);
                            old_cursor.next(new_snapshot);
                        }
                        cmp::Ordering::Greater => {
                            start.get_or_insert(old_hunk.buffer_range.start);
                            end.replace(old_hunk.buffer_range.end);
                            old_cursor.next(new_snapshot);
                        }
                    }
                }
                (Some(new_hunk), None) => {
                    start.get_or_insert(new_hunk.buffer_range.start);
                    end.replace(new_hunk.buffer_range.end);
                    new_cursor.next(new_snapshot);
                }
                (None, Some(old_hunk)) => {
                    start.get_or_insert(old_hunk.buffer_range.start);
                    end.replace(old_hunk.buffer_range.end);
                    old_cursor.next(new_snapshot);
                }
                (None, None) => break,
            }
        }

        start.zip(end).map(|(start, end)| start..end)
    }
}

fn compute_hunks(
    diff_base: Option<Arc<String>>,
    buffer: text::BufferSnapshot,
) -> SumTree<InternalDiffHunk> {
    let mut tree = SumTree::new(&buffer);

    if let Some(diff_base) = diff_base {
        let buffer_text = buffer.as_rope().to_string();

        let mut options = GitOptions::default();
        options.context_lines(0);
        let patch = GitPatch::from_buffers(
            diff_base.as_bytes(),
            None,
            buffer_text.as_bytes(),
            None,
            Some(&mut options),
        )
        .log_err();

        // A common case in Zed is that the empty buffer is represented as just a newline,
        // but if we just compute a naive diff you get a "preserved" line in the middle,
        // which is a bit odd.
        if buffer_text == "\n" && diff_base.ends_with("\n") && diff_base.len() > 1 {
            tree.push(
                InternalDiffHunk {
                    buffer_range: buffer.anchor_before(0)..buffer.anchor_before(0),
                    diff_base_byte_range: 0..diff_base.len() - 1,
                },
                &buffer,
            );
            return tree;
        }

        if let Some(patch) = patch {
            let mut divergence = 0;
            for hunk_index in 0..patch.num_hunks() {
                let hunk = process_patch_hunk(&patch, hunk_index, &buffer, &mut divergence);
                tree.push(hunk, &buffer);
            }
        }
    }

    tree
}

fn process_patch_hunk(
    patch: &GitPatch<'_>,
    hunk_index: usize,
    buffer: &text::BufferSnapshot,
    buffer_row_divergence: &mut i64,
) -> InternalDiffHunk {
    let line_item_count = patch.num_lines_in_hunk(hunk_index).unwrap();
    assert!(line_item_count > 0);

    let mut first_deletion_buffer_row: Option<u32> = None;
    let mut buffer_row_range: Option<Range<u32>> = None;
    let mut diff_base_byte_range: Option<Range<usize>> = None;

    for line_index in 0..line_item_count {
        let line = patch.line_in_hunk(hunk_index, line_index).unwrap();
        let kind = line.origin_value();
        let content_offset = line.content_offset() as isize;
        let content_len = line.content().len() as isize;

        if kind == GitDiffLineType::Addition {
            *buffer_row_divergence += 1;
            let row = line.new_lineno().unwrap().saturating_sub(1);

            match &mut buffer_row_range {
                Some(buffer_row_range) => buffer_row_range.end = row + 1,
                None => buffer_row_range = Some(row..row + 1),
            }
        }

        if kind == GitDiffLineType::Deletion {
            let end = content_offset + content_len;

            match &mut diff_base_byte_range {
                Some(head_byte_range) => head_byte_range.end = end as usize,
                None => diff_base_byte_range = Some(content_offset as usize..end as usize),
            }

            if first_deletion_buffer_row.is_none() {
                let old_row = line.old_lineno().unwrap().saturating_sub(1);
                let row = old_row as i64 + *buffer_row_divergence;
                first_deletion_buffer_row = Some(row as u32);
            }

            *buffer_row_divergence -= 1;
        }
    }

    //unwrap_or deletion without addition
    let buffer_row_range = buffer_row_range.unwrap_or_else(|| {
        //we cannot have an addition-less hunk without deletion(s) or else there would be no hunk
        let row = first_deletion_buffer_row.unwrap();
        row..row
    });

    //unwrap_or addition without deletion
    let diff_base_byte_range = diff_base_byte_range.unwrap_or(0..0);

    let start = Point::new(buffer_row_range.start, 0);
    let end = Point::new(buffer_row_range.end, 0);
    let buffer_range = buffer.anchor_before(start)..buffer.anchor_before(end);
    InternalDiffHunk {
        buffer_range,
        diff_base_byte_range,
    }
}

impl std::fmt::Debug for BufferDiff {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("BufferChangeSet")
            .field("buffer_id", &self.buffer_id)
            .field("snapshot", &self.inner)
            .finish()
    }
}

pub enum BufferDiffEvent {
    DiffChanged {
        changed_range: Option<Range<text::Anchor>>,
    },
    LanguageChanged,
}

impl EventEmitter<BufferDiffEvent> for BufferDiff {}

impl BufferDiff {
    #[cfg(test)]
    fn build_sync(
        buffer: text::BufferSnapshot,
        diff_base: String,
        cx: &mut gpui::TestAppContext,
    ) -> BufferDiffInner {
        let snapshot =
            cx.update(|cx| Self::build(buffer, Some(Arc::new(diff_base)), None, None, cx));
        cx.executor().block(snapshot)
    }

    fn build(
        buffer: text::BufferSnapshot,
        diff_base: Option<Arc<String>>,
        language: Option<Arc<Language>>,
        language_registry: Option<Arc<LanguageRegistry>>,
        cx: &mut App,
    ) -> impl Future<Output = BufferDiffInner> {
        let base_text_snapshot = diff_base.as_ref().map(|base_text| {
            language::Buffer::build_snapshot(
                Rope::from(base_text.as_str()),
                language.clone(),
                language_registry.clone(),
                cx,
            )
        });
        let base_text_snapshot = cx
            .background_executor()
            .spawn(OptionFuture::from(base_text_snapshot));

        let hunks = cx.background_executor().spawn({
            let buffer = buffer.clone();
            async move { compute_hunks(diff_base, buffer) }
        });

        async move {
            let (base_text, hunks) = futures::join!(base_text_snapshot, hunks);
            BufferDiffInner { base_text, hunks }
        }
    }

    fn build_with_base_buffer(
        buffer: text::BufferSnapshot,
        diff_base: Option<Arc<String>>,
        diff_base_buffer: Option<language::BufferSnapshot>,
        cx: &App,
    ) -> impl Future<Output = BufferDiffInner> {
        cx.background_executor().spawn(async move {
            BufferDiffInner {
                hunks: compute_hunks(diff_base, buffer),
                base_text: diff_base_buffer,
            }
        })
    }

    fn build_empty(buffer: &text::BufferSnapshot) -> BufferDiffInner {
        BufferDiffInner {
            hunks: SumTree::new(buffer),
            base_text: None,
        }
    }

    pub fn build_with_single_insertion(
        insertion_present_in_secondary_diff: bool,
        cx: &mut App,
    ) -> BufferDiffSnapshot {
        let base_text = language::Buffer::build_empty_snapshot(cx);
        let hunks = SumTree::from_item(
            InternalDiffHunk {
                buffer_range: Anchor::MIN..Anchor::MAX,
                diff_base_byte_range: 0..0,
            },
            &base_text,
        );
        BufferDiffSnapshot {
            inner: BufferDiffInner {
                hunks: hunks.clone(),
                base_text: Some(base_text.clone()),
            },
            secondary_diff: if insertion_present_in_secondary_diff {
                Some(Box::new(BufferDiffSnapshot {
                    inner: BufferDiffInner {
                        hunks,
                        base_text: Some(base_text),
                    },
                    secondary_diff: None,
                }))
            } else {
                None
            },
        }
    }

    pub fn set_secondary_diff(&mut self, diff: Entity<BufferDiff>) {
        self.secondary_diff = Some(diff);
    }

    pub fn secondary_diff(&self) -> Option<Entity<BufferDiff>> {
        Some(self.secondary_diff.as_ref()?.clone())
    }

    pub fn range_to_hunk_range(
        &self,
        range: Range<Anchor>,
        buffer: &text::BufferSnapshot,
        cx: &App,
    ) -> Option<Range<Anchor>> {
        let start = self
            .hunks_intersecting_range(range.clone(), &buffer, cx)
            .next()?
            .buffer_range
            .start;
        let end = self
            .hunks_intersecting_range_rev(range.clone(), &buffer)
            .next()?
            .buffer_range
            .end;
        Some(start..end)
    }

    #[allow(clippy::too_many_arguments)]
    pub async fn update_diff(
        this: Entity<BufferDiff>,
        buffer: text::BufferSnapshot,
        base_text: Option<Arc<String>>,
        base_text_changed: bool,
        language_changed: bool,
        language: Option<Arc<Language>>,
        language_registry: Option<Arc<LanguageRegistry>>,
        cx: &mut AsyncApp,
    ) -> anyhow::Result<Option<Range<Anchor>>> {
        let snapshot = if base_text_changed || language_changed {
            cx.update(|cx| {
                Self::build(
                    buffer.clone(),
                    base_text,
                    language.clone(),
                    language_registry.clone(),
                    cx,
                )
            })?
            .await
        } else {
            this.read_with(cx, |this, cx| {
                Self::build_with_base_buffer(
                    buffer.clone(),
                    base_text,
                    this.base_text().cloned(),
                    cx,
                )
            })?
            .await
        };

        this.update(cx, |this, _| this.set_state(snapshot, &buffer))
    }

    pub fn update_diff_from(
        &mut self,
        buffer: &text::BufferSnapshot,
        other: &Entity<Self>,
        cx: &mut Context<Self>,
    ) -> Option<Range<Anchor>> {
        let other = other.read(cx).inner.clone();
        self.set_state(other, buffer)
    }

    fn set_state(
        &mut self,
        inner: BufferDiffInner,
        buffer: &text::BufferSnapshot,
    ) -> Option<Range<Anchor>> {
        let changed_range = match (self.inner.base_text.as_ref(), inner.base_text.as_ref()) {
            (None, None) => None,
            (Some(old), Some(new)) if old.remote_id() == new.remote_id() => {
                inner.compare(&self.inner, buffer)
            }
            _ => Some(text::Anchor::MIN..text::Anchor::MAX),
        };
        self.inner = inner;
        changed_range
    }

    pub fn base_text(&self) -> Option<&language::BufferSnapshot> {
        self.inner.base_text.as_ref()
    }

    pub fn snapshot(&self, cx: &App) -> BufferDiffSnapshot {
        BufferDiffSnapshot {
            inner: self.inner.clone(),
            secondary_diff: self
                .secondary_diff
                .as_ref()
                .map(|diff| Box::new(diff.read(cx).snapshot(cx))),
        }
    }

    pub fn hunks_intersecting_range<'a>(
        &'a self,
        range: Range<text::Anchor>,
        buffer_snapshot: &'a text::BufferSnapshot,
        cx: &'a App,
    ) -> impl 'a + Iterator<Item = DiffHunk> {
        let unstaged_counterpart = self
            .secondary_diff
            .as_ref()
            .map(|diff| &diff.read(cx).inner);
        self.inner
            .hunks_intersecting_range(range, buffer_snapshot, unstaged_counterpart)
    }

    pub fn hunks_intersecting_range_rev<'a>(
        &'a self,
        range: Range<text::Anchor>,
        buffer_snapshot: &'a text::BufferSnapshot,
    ) -> impl 'a + Iterator<Item = DiffHunk> {
        self.inner
            .hunks_intersecting_range_rev(range, buffer_snapshot)
    }

    pub fn hunks_in_row_range<'a>(
        &'a self,
        range: Range<u32>,
        buffer: &'a text::BufferSnapshot,
        cx: &'a App,
    ) -> impl 'a + Iterator<Item = DiffHunk> {
        let start = buffer.anchor_before(Point::new(range.start, 0));
        let end = buffer.anchor_after(Point::new(range.end, 0));
        self.hunks_intersecting_range(start..end, buffer, cx)
    }

    /// Used in cases where the change set isn't derived from git.
    pub fn set_base_text(
        &mut self,
        base_buffer: Entity<language::Buffer>,
        buffer: text::BufferSnapshot,
        cx: &mut Context<Self>,
    ) -> oneshot::Receiver<()> {
        let (tx, rx) = oneshot::channel();
        let this = cx.weak_entity();
        let base_buffer = base_buffer.read(cx);
        let language_registry = base_buffer.language_registry();
        let base_buffer = base_buffer.snapshot();
        let base_text = Arc::new(base_buffer.text());

        let snapshot = BufferDiff::build(
            buffer.clone(),
            Some(base_text),
            base_buffer.language().cloned(),
            language_registry,
            cx,
        );
        let complete_on_drop = util::defer(|| {
            tx.send(()).ok();
        });
        cx.spawn(|_, mut cx| async move {
            let snapshot = snapshot.await;
            let Some(this) = this.upgrade() else {
                return;
            };
            this.update(&mut cx, |this, _| {
                this.set_state(snapshot, &buffer);
            })
            .log_err();
            drop(complete_on_drop)
        })
        .detach();
        rx
    }

    #[cfg(any(test, feature = "test-support"))]
    pub fn base_text_string(&self) -> Option<String> {
        self.inner.base_text.as_ref().map(|buffer| buffer.text())
    }

    pub fn new(buffer: &text::BufferSnapshot) -> Self {
        BufferDiff {
            buffer_id: buffer.remote_id(),
            inner: BufferDiff::build_empty(buffer),
            secondary_diff: None,
        }
    }

    #[cfg(any(test, feature = "test-support"))]
    pub fn new_with_base_text(
        base_text: &str,
        buffer: &Entity<language::Buffer>,
        cx: &mut App,
    ) -> Self {
        let mut base_text = base_text.to_owned();
        text::LineEnding::normalize(&mut base_text);
        let snapshot = BufferDiff::build(
            buffer.read(cx).text_snapshot(),
            Some(base_text.into()),
            None,
            None,
            cx,
        );
        let snapshot = cx.background_executor().block(snapshot);
        BufferDiff {
            buffer_id: buffer.read(cx).remote_id(),
            inner: snapshot,
            secondary_diff: None,
        }
    }

    #[cfg(any(test, feature = "test-support"))]
    pub fn recalculate_diff_sync(&mut self, buffer: text::BufferSnapshot, cx: &mut Context<Self>) {
        let base_text = self
            .inner
            .base_text
            .as_ref()
            .map(|base_text| base_text.text());
        let snapshot = BufferDiff::build_with_base_buffer(
            buffer.clone(),
            base_text.clone().map(Arc::new),
            self.inner.base_text.clone(),
            cx,
        );
        let snapshot = cx.background_executor().block(snapshot);
        let changed_range = self.set_state(snapshot, &buffer);
        cx.emit(BufferDiffEvent::DiffChanged { changed_range });
    }
}

impl DiffHunk {
    pub fn status(&self) -> DiffHunkStatus {
        if self.buffer_range.start == self.buffer_range.end {
            DiffHunkStatus::Removed(self.secondary_status)
        } else if self.diff_base_byte_range.is_empty() {
            DiffHunkStatus::Added(self.secondary_status)
        } else {
            DiffHunkStatus::Modified(self.secondary_status)
        }
    }
}

impl DiffHunkStatus {
    pub fn is_removed(&self) -> bool {
        matches!(self, DiffHunkStatus::Removed(_))
    }

    #[cfg(any(test, feature = "test-support"))]
    pub fn removed() -> Self {
        DiffHunkStatus::Removed(DiffHunkSecondaryStatus::None)
    }

    #[cfg(any(test, feature = "test-support"))]
    pub fn added() -> Self {
        DiffHunkStatus::Added(DiffHunkSecondaryStatus::None)
    }

    #[cfg(any(test, feature = "test-support"))]
    pub fn modified() -> Self {
        DiffHunkStatus::Modified(DiffHunkSecondaryStatus::None)
    }
}

/// Range (crossing new lines), old, new
#[cfg(any(test, feature = "test-support"))]
#[track_caller]
pub fn assert_hunks<Iter>(
    diff_hunks: Iter,
    buffer: &text::BufferSnapshot,
    diff_base: &str,
    expected_hunks: &[(Range<u32>, &str, &str, DiffHunkStatus)],
) where
    Iter: Iterator<Item = DiffHunk>,
{
    let actual_hunks = diff_hunks
        .map(|hunk| {
            (
                hunk.row_range.clone(),
                &diff_base[hunk.diff_base_byte_range.clone()],
                buffer
                    .text_for_range(
                        Point::new(hunk.row_range.start, 0)..Point::new(hunk.row_range.end, 0),
                    )
                    .collect::<String>(),
                hunk.status(),
            )
        })
        .collect::<Vec<_>>();

    let expected_hunks: Vec<_> = expected_hunks
        .iter()
        .map(|(r, s, h, status)| (r.clone(), *s, h.to_string(), *status))
        .collect();

    assert_eq!(actual_hunks, expected_hunks);
}

#[cfg(test)]
mod tests {
    use std::assert_eq;

    use super::*;
    use gpui::TestAppContext;
    use text::{Buffer, BufferId};
    use unindent::Unindent as _;

    #[gpui::test]
    async fn test_buffer_diff_simple(cx: &mut gpui::TestAppContext) {
        let diff_base = "
            one
            two
            three
        "
        .unindent();

        let buffer_text = "
            one
            HELLO
            three
        "
        .unindent();

        let mut buffer = Buffer::new(0, BufferId::new(1).unwrap(), buffer_text);
        let mut diff = BufferDiff::build_sync(buffer.clone(), diff_base.clone(), cx);
        assert_hunks(
            diff.hunks_intersecting_range(Anchor::MIN..Anchor::MAX, &buffer, None),
            &buffer,
            &diff_base,
            &[(1..2, "two\n", "HELLO\n", DiffHunkStatus::modified())],
        );

        buffer.edit([(0..0, "point five\n")]);
        diff = BufferDiff::build_sync(buffer.clone(), diff_base.clone(), cx);
        assert_hunks(
            diff.hunks_intersecting_range(Anchor::MIN..Anchor::MAX, &buffer, None),
            &buffer,
            &diff_base,
            &[
                (0..1, "", "point five\n", DiffHunkStatus::added()),
                (2..3, "two\n", "HELLO\n", DiffHunkStatus::modified()),
            ],
        );

        diff = BufferDiff::build_empty(&buffer);
        assert_hunks(
            diff.hunks_intersecting_range(Anchor::MIN..Anchor::MAX, &buffer, None),
            &buffer,
            &diff_base,
            &[],
        );
    }

    #[gpui::test]
    async fn test_buffer_diff_with_secondary(cx: &mut gpui::TestAppContext) {
        let head_text = "
            zero
            one
            two
            three
            four
            five
            six
            seven
            eight
            nine
        "
        .unindent();

        let index_text = "
            zero
            one
            TWO
            three
            FOUR
            five
            six
            seven
            eight
            NINE
        "
        .unindent();

        let buffer_text = "
            zero
            one
            TWO
            three
            FOUR
            FIVE
            six
            SEVEN
            eight
            nine
        "
        .unindent();

        let buffer = Buffer::new(0, BufferId::new(1).unwrap(), buffer_text);
        let unstaged_diff = BufferDiff::build_sync(buffer.clone(), index_text.clone(), cx);

        let uncommitted_diff = BufferDiff::build_sync(buffer.clone(), head_text.clone(), cx);

        let expected_hunks = vec![
            (
                2..3,
                "two\n",
                "TWO\n",
                DiffHunkStatus::Modified(DiffHunkSecondaryStatus::None),
            ),
            (
                4..6,
                "four\nfive\n",
                "FOUR\nFIVE\n",
                DiffHunkStatus::Modified(DiffHunkSecondaryStatus::OverlapsWithSecondaryHunk),
            ),
            (
                7..8,
                "seven\n",
                "SEVEN\n",
                DiffHunkStatus::Modified(DiffHunkSecondaryStatus::HasSecondaryHunk),
            ),
        ];

        assert_hunks(
            uncommitted_diff.hunks_intersecting_range(
                Anchor::MIN..Anchor::MAX,
                &buffer,
                Some(&unstaged_diff),
            ),
            &buffer,
            &head_text,
            &expected_hunks,
        );
    }

    #[gpui::test]
    async fn test_buffer_diff_range(cx: &mut TestAppContext) {
        let diff_base = Arc::new(
            "
            one
            two
            three
            four
            five
            six
            seven
            eight
            nine
            ten
        "
            .unindent(),
        );

        let buffer_text = "
            A
            one
            B
            two
            C
            three
            HELLO
            four
            five
            SIXTEEN
            seven
            eight
            WORLD
            nine

            ten

        "
        .unindent();

        let buffer = Buffer::new(0, BufferId::new(1).unwrap(), buffer_text);
        let diff = cx
            .update(|cx| {
                BufferDiff::build(buffer.snapshot(), Some(diff_base.clone()), None, None, cx)
            })
            .await;
        assert_eq!(
            diff.hunks_intersecting_range(Anchor::MIN..Anchor::MAX, &buffer, None)
                .count(),
            8
        );

        assert_hunks(
            diff.hunks_intersecting_range(
                buffer.anchor_before(Point::new(7, 0))..buffer.anchor_before(Point::new(12, 0)),
                &buffer,
                None,
            ),
            &buffer,
            &diff_base,
            &[
                (6..7, "", "HELLO\n", DiffHunkStatus::added()),
                (9..10, "six\n", "SIXTEEN\n", DiffHunkStatus::modified()),
                (12..13, "", "WORLD\n", DiffHunkStatus::added()),
            ],
        );
    }

    #[gpui::test]
    async fn test_buffer_diff_compare(cx: &mut TestAppContext) {
        let base_text = "
            zero
            one
            two
            three
            four
            five
            six
            seven
            eight
            nine
        "
        .unindent();

        let buffer_text_1 = "
            one
            three
            four
            five
            SIX
            seven
            eight
            NINE
        "
        .unindent();

        let mut buffer = Buffer::new(0, BufferId::new(1).unwrap(), buffer_text_1);

        let empty_diff = BufferDiff::build_empty(&buffer);
        let diff_1 = BufferDiff::build_sync(buffer.clone(), base_text.clone(), cx);
        let range = diff_1.compare(&empty_diff, &buffer).unwrap();
        assert_eq!(range.to_point(&buffer), Point::new(0, 0)..Point::new(8, 0));

        // Edit does not affect the diff.
        buffer.edit_via_marked_text(
            &"
                one
                three
                four
                five
                «SIX.5»
                seven
                eight
                NINE
            "
            .unindent(),
        );
        let diff_2 = BufferDiff::build_sync(buffer.clone(), base_text.clone(), cx);
        assert_eq!(None, diff_2.compare(&diff_1, &buffer));

        // Edit turns a deletion hunk into a modification.
        buffer.edit_via_marked_text(
            &"
                one
                «THREE»
                four
                five
                SIX.5
                seven
                eight
                NINE
            "
            .unindent(),
        );
        let diff_3 = BufferDiff::build_sync(buffer.clone(), base_text.clone(), cx);
        let range = diff_3.compare(&diff_2, &buffer).unwrap();
        assert_eq!(range.to_point(&buffer), Point::new(1, 0)..Point::new(2, 0));

        // Edit turns a modification hunk into a deletion.
        buffer.edit_via_marked_text(
            &"
                one
                THREE
                four
                five«»
                seven
                eight
                NINE
            "
            .unindent(),
        );
        let diff_4 = BufferDiff::build_sync(buffer.clone(), base_text.clone(), cx);
        let range = diff_4.compare(&diff_3, &buffer).unwrap();
        assert_eq!(range.to_point(&buffer), Point::new(3, 4)..Point::new(4, 0));

        // Edit introduces a new insertion hunk.
        buffer.edit_via_marked_text(
            &"
                one
                THREE
                four«
                FOUR.5
                »five
                seven
                eight
                NINE
            "
            .unindent(),
        );
        let diff_5 = BufferDiff::build_sync(buffer.snapshot(), base_text.clone(), cx);
        let range = diff_5.compare(&diff_4, &buffer).unwrap();
        assert_eq!(range.to_point(&buffer), Point::new(3, 0)..Point::new(4, 0));

        // Edit removes a hunk.
        buffer.edit_via_marked_text(
            &"
                one
                THREE
                four
                FOUR.5
                five
                seven
                eight
                «nine»
            "
            .unindent(),
        );
        let diff_6 = BufferDiff::build_sync(buffer.snapshot(), base_text, cx);
        let range = diff_6.compare(&diff_5, &buffer).unwrap();
        assert_eq!(range.to_point(&buffer), Point::new(7, 0)..Point::new(8, 0));
    }
}