//! Text diff computation for incremental buffer updates.
//!
//! This module provides functionality for computing minimal diffs between two text strings,
//! which is used for auto-reloading files without wiping undo history or disrupting anchors.

use std::ops::Range;

use imara_diff::{Algorithm, Diff, InternedInput, Token};
use string_offset::{ByteOffset, CharOffset};

use super::buffer::{Buffer, ToBufferCharOffset};

/// A computed diff between two strings.
///
/// The edits are represented as byte ranges in the old text and their replacement strings.
/// These can be applied to transform the old text into the new text.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TextDiff {
    /// List of edits: (old_byte_range, new_text)
    pub edits: Vec<(Range<usize>, String)>,
}

impl TextDiff {
    /// Returns true if this diff represents no changes.
    pub fn is_empty(&self) -> bool {
        self.edits.is_empty()
    }

    /// Convert byte-range edits to CharOffset-range edits.
    ///
    /// The buffer uses 1-indexed coordinates (first editable character is at CharOffset(1)).
    /// The diff byte offsets are 0-indexed relative to the plain text, so we add 1 to
    /// convert to the buffer's 1-indexed system before using to_buffer_char_offset.
    pub fn to_char_offset_edits(&self, buffer: &Buffer) -> Vec<(Range<CharOffset>, String)> {
        self.edits
            .iter()
            .map(|(byte_range, new_text)| {
                // Add 1 to convert from 0-indexed plain text byte offset to 1-indexed buffer byte offset
                let start = ByteOffset::from(byte_range.start + 1).to_buffer_char_offset(buffer);
                let end = ByteOffset::from(byte_range.end + 1).to_buffer_char_offset(buffer);
                (start..end, new_text.clone())
            })
            .collect()
    }
}

/// Compute a diff between two strings.
///
/// This uses a line-based diff algorithm (Histogram) for efficiency.
/// Returns a list of edits as (byte_range_in_old, replacement_text) pairs.
pub async fn text_diff(old_text: &str, new_text: &str) -> TextDiff {
    let input = InternedInput::new(old_text, new_text);
    // Yield here to prevent doing more work if the task is aborted.
    futures_lite::future::yield_now().await;

    // Only compute line-based diff for now. Zed does more fine-grained word-level diffing for smaller hunks
    // but I don't think it's worth it for our use case.
    let edits = diff_internal(&input, new_text).await;

    TextDiff { edits }
}

async fn diff_internal(input: &InternedInput<&str>, new_text: &str) -> Vec<(Range<usize>, String)> {
    let mut old_offset = 0;
    let mut new_offset = 0;
    let mut old_token_ix = 0;
    let mut new_token_ix = 0;
    let mut edits = Vec::new();

    let diff = Diff::compute(Algorithm::Histogram, input);

    // Yield here to prevent doing more work if the task is aborted.
    futures_lite::future::yield_now().await;

    for hunk in diff.hunks() {
        // Calculate byte offsets for unchanged tokens before this hunk
        old_offset += token_len(
            input,
            &input.before[old_token_ix as usize..hunk.before.start as usize],
        );
        new_offset += token_len(
            input,
            &input.after[new_token_ix as usize..hunk.after.start as usize],
        );

        // Calculate byte lengths of the changed tokens
        let old_len = token_len(
            input,
            &input.before[hunk.before.start as usize..hunk.before.end as usize],
        );
        let new_len = token_len(
            input,
            &input.after[hunk.after.start as usize..hunk.after.end as usize],
        );

        let old_byte_range = old_offset..old_offset + old_len;
        let new_byte_range = new_offset..new_offset + new_len;

        old_token_ix = hunk.before.end;
        new_token_ix = hunk.after.end;
        old_offset = old_byte_range.end;
        new_offset = new_byte_range.end;

        let replacement = if new_byte_range.is_empty() {
            String::new()
        } else {
            new_text[new_byte_range].to_string()
        };
        edits.push((old_byte_range, replacement));
    }

    edits
}

/// Calculate total byte length of a sequence of tokens.
fn token_len(input: &InternedInput<&str>, tokens: &[Token]) -> usize {
    tokens
        .iter()
        .map(|token| input.interner[*token].len())
        .sum()
}