use std::ops::{Add, Sub};

use itertools::Itertools;
use num_traits::SaturatingSub;
use string_offset::CharOffset;

use super::FrameOffset;

#[cfg(test)]
#[path = "offset_map_tests.rs"]
mod tests;

/// Mapping between visible character offsets and interactive content character offsets. Due to
/// placeholder text, not all characters painted on the screen correspond to interactive characters
/// in the content model.
///
/// The mapping model assumes that, within the overall set of characters in a text frame, only
/// certain character runs are interactive. Within those runs, there's a 1:1 mapping between
/// `char`s in the content model and `char`s in the text frame. It translates in two directions:
/// * From a [`CharOffset`] relative to the start of the content model block (a [`super::Paragraph`])
///   to the character index in the [`warpui_core::text_layout::TextFrame`].
/// * From a [`FrameOffset`] in the `TextFrame` to the closest `CharOffset` in the content model
///   block (for example, clicking within a placeholder should snap the cursor to a regular content
///   character).
///
/// An interactive character is one that the user can select and edit.
#[derive(Debug, Clone)]
pub struct OffsetMap {
    /// Sorted list of interactive content runs.
    runs: Vec<SelectableTextRun>,
}

/// A run of selectable/interactive content in the [`OffsetMap`]. This includes all user-written
/// characters, but not placeholder text.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SelectableTextRun {
    /// The offset of the first content-character in this run.
    pub content_start: CharOffset,
    /// The offset of the first [`TextFrame`] visible character in this run.
    pub frame_start: FrameOffset,
    /// The total number of characters in this run. The run length is the same for both content
    /// characters and text frame characters. That is, this run represents:
    /// * Characters `content_start..content_start+length` within the containing paragraph
    /// * Characters `frame_start..frame_start+length` within the containing `TextFrame`
    pub length: usize,
}

impl OffsetMap {
    /// Creates a new [`OffsetMap`] that translates 1:1 between visible character offsets and
    /// interactive content character offsets.
    pub fn direct(length: usize) -> Self {
        Self::new(vec![SelectableTextRun {
            content_start: CharOffset::zero(),
            frame_start: FrameOffset::zero(),
            length,
        }])
    }

    pub fn new(mut runs: Vec<SelectableTextRun>) -> Self {
        runs.sort_unstable_by_key(|r| r.frame_start);
        if cfg!(debug_assertions) {
            // Content- and frame-offsets should both increase from run to run.
            for (a, b) in runs.iter().tuple_windows() {
                assert!(a.content_start < b.content_start, "Runs must be ascending");
            }
        }
        Self { runs }
    }

    /// Translate a visible character to the closest content character.
    pub fn to_content(&self, offset: FrameOffset) -> CharOffset {
        self.translate(offset)
    }

    /// Translate a content character to the corresponding visible character.
    pub fn to_frame(&self, offset: CharOffset) -> FrameOffset {
        // When going from content to frame offsets, the character is almost always going to be
        // inside an interactive run. The exception is the placeholder marker character, and so
        // it's simpler to reuse the translation algorithm from the other direction rather than
        // detect and handle this special case.
        self.translate(offset)
    }

    /// Translate from one kind of offset to the other. If the source offset is within an interactive
    /// run, this returns the exact location of the character within that run. Otherwise, it rounds
    /// up or down to the nearest interactive run.
    fn translate<T: ParagraphOffset, U: ParagraphOffset>(&self, offset: T) -> U {
        // Find the runs before and after `offset`, and calculate for each:
        // - The absolute distance from it to `offset`
        // - The translated offset according to it
        let after_idx = self.runs.partition_point(|run| T::start(run) < offset);

        let after = self.runs.get(after_idx).map(|run| {
            let distance = T::start(run) - offset;
            // If the run after `offset` is closer, then snap to the start of that run (e.g. the
            // first regular character after a placeholder).
            (distance, U::start(run))
        });

        let before = after_idx
            .checked_sub(1)
            .and_then(|idx| self.runs.get(idx))
            .map(|run| {
                // For the before run, we measure the distance from its end to offset. However, the
                // offset could be within the run, so we clamp down to 0.
                let run_end = T::start(run) + run.length;
                let distance = offset.saturating_sub(&run_end);
                // If we pick the before run, we essentially rebase it onto the destination start, but then
                // clamp to stay within the run.
                let translation =
                    U::start(run) + (offset - T::start(run)).as_usize().min(run.length);
                (distance, translation)
            });

        match (before, after) {
            (None, None) => U::zero(), // This should only happen if the frame is empty.
            (None, Some((_, translation))) => translation,
            (Some((_, translation)), None) => translation,
            (
                Some((before_distance, before_translation)),
                Some((after_distance, after_translation)),
            ) => {
                if before_distance < after_distance {
                    before_translation
                } else {
                    after_translation
                }
            }
        }
    }
}

/// Abstracts over [`FrameOffset`] and [`CharOffset`] so that we can use the same conversion
/// algorithm for both.
trait ParagraphOffset:
    Add<usize, Output = Self> + Ord + Sub<Output = Self> + SaturatingSub + Copy + Sized
{
    /// Gets the start offset of a [`SelectableTextRun`] for this offset/coordinate system.
    fn start(run: &SelectableTextRun) -> Self;

    fn zero() -> Self;

    fn as_usize(self) -> usize;
}

impl ParagraphOffset for CharOffset {
    fn start(run: &SelectableTextRun) -> Self {
        run.content_start
    }

    fn zero() -> Self {
        CharOffset::zero()
    }

    fn as_usize(self) -> usize {
        CharOffset::as_usize(self)
    }
}

impl ParagraphOffset for FrameOffset {
    fn start(run: &SelectableTextRun) -> Self {
        run.frame_start
    }

    fn zero() -> Self {
        FrameOffset::zero()
    }

    fn as_usize(self) -> usize {
        FrameOffset::as_usize(self)
    }
}