//! Text selection and cursor positioning for inline content.

//!

//! This module provides data structures for managing text cursors and selection ranges

//! in a bidirectional (Bidi) and line-breaking aware manner. It handles:

//!

//! - **Grapheme cluster identification**: Unicode-aware character boundaries

//! - **Bidi support**: Cursor movement in mixed LTR/RTL text

//! - **Stable positions**: Selection anchors survive layout changes

//! - **Affinity tracking**: Cursor position at leading/trailing edges

//! - **Multi-node selection**: Browser-style selection spanning multiple DOM nodes

//!

//! # Architecture

//!

//! Text positions are represented as:

//! - `ContentIndex`: Logical position in the original inline content array

//! - `GraphemeClusterId`: Stable identifier for a grapheme cluster (survives reordering)

//! - `TextCursor`: Precise cursor location with leading/trailing affinity

//! - `SelectionRange`: Start and end cursors defining a selection

//!

//! Multi-node selection uses an Anchor/Focus model (W3C Selection API):

//! - `SelectionAnchor`: Fixed point where user started selection (mousedown)

//! - `SelectionFocus`: Movable point where selection currently ends (drag position)

//! - `TextSelection`: Complete selection state spanning potentially multiple IFC roots

//!

//! # Use Cases

//!

//! - Text editing: Insert/delete at cursor position

//! - Selection rendering: Highlight selected text across multiple nodes

//! - Keyboard navigation: Move cursor by grapheme/word/line

//! - Mouse selection: Convert pixel coordinates to text positions

//! - Drag selection: Extend selection across multiple DOM nodes

//!

//! # Examples

//!

//! ```rust,no_run

//! use azul_core::selection::{CursorAffinity, GraphemeClusterId, TextCursor};

//!

//! let cursor = TextCursor {

//!     cluster_id: GraphemeClusterId {

//!         source_run: 0,

//!         start_byte_in_run: 0,

//!     },

//!     affinity: CursorAffinity::Leading,

//! };

//! ```

use alloc::collections::BTreeMap;

use alloc::vec::Vec;

use core::sync::atomic::{AtomicU64, Ordering};

use crate::dom::{DomId, DomNodeId, NodeId};

use crate::geom::{LogicalPosition, LogicalRect};

/// A stable, logical pointer to an item within the original `InlineContent` array.

///

/// This structure eliminates the need for string concatenation and byte-offset math

/// by tracking both the run index and the item index within that run.

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]

pub struct ContentIndex {

    /// The index of the `InlineContent` run in the original input array.

    pub run_index: u32,

    /// The byte index of the character or item *within* that run's string.

    pub item_index: u32,

}

/// A stable, logical identifier for a grapheme cluster.

///

/// This survives Bidi reordering and line breaking, making it ideal for tracking

/// text positions for selection and cursor logic.

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]

#[repr(C)]

pub struct GraphemeClusterId {

    /// The `run_index` from the source `ContentIndex`.

    pub source_run: u32,

    /// The byte index of the start of the cluster in its original `StyledRun`.

    pub start_byte_in_run: u32,

}

/// Represents the logical position of the cursor *between* two grapheme clusters

/// or at the start/end of the text.

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]

#[repr(C)]

pub enum CursorAffinity {

    /// The cursor is at the leading edge of the character (left in LTR, right in RTL).

    Leading,

    /// The cursor is at the trailing edge of the character (right in LTR, left in RTL).

    Trailing,

}

/// Represents a precise cursor location in the logical text.

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]

#[repr(C)]

pub struct TextCursor {

    /// The grapheme cluster the cursor is associated with.

    pub cluster_id: GraphemeClusterId,

    /// The edge of the cluster the cursor is on.

    pub affinity: CursorAffinity,

}

impl_option!(

    TextCursor,

    OptionTextCursor,

    [Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd]

);

/// Represents a range of selected text. The direction is implicit (start can be

/// logically after end if selecting backwards).

#[derive(Debug, PartialOrd, Ord, Clone, Copy, PartialEq, Eq, Hash)]

#[repr(C)]

pub struct SelectionRange {

    pub start: TextCursor,

    pub end: TextCursor,

}

impl_option!(

    SelectionRange,

    OptionSelectionRange,

    [Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd]

);

impl_vec!(SelectionRange, SelectionRangeVec, SelectionRangeVecDestructor, SelectionRangeVecDestructorType, SelectionRangeVecSlice, OptionSelectionRange);

impl_vec_debug!(SelectionRange, SelectionRangeVec);

impl_vec_clone!(

    SelectionRange,

    SelectionRangeVec,

    SelectionRangeVecDestructor

);

impl_vec_partialeq!(SelectionRange, SelectionRangeVec);

impl_vec_partialord!(SelectionRange, SelectionRangeVec);

/// A single selection, which can be either a blinking cursor or a highlighted range.

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]

#[repr(C, u8)]

pub enum Selection {

    Cursor(TextCursor),

    Range(SelectionRange),

}

impl_option!(

    Selection,

    OptionSelection,

    [Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord]

);

impl_vec!(Selection, SelectionVec, SelectionVecDestructor, SelectionVecDestructorType, SelectionVecSlice, OptionSelection);

impl_vec_debug!(Selection, SelectionVec);

impl_vec_clone!(Selection, SelectionVec, SelectionVecDestructor);

impl_vec_partialeq!(Selection, SelectionVec);

impl_vec_partialord!(Selection, SelectionVec);

/// The complete selection state for a single text block, supporting multiple cursors/ranges.

#[derive(Debug, Clone, PartialEq)]

#[repr(C)]

pub struct SelectionState {

    /// A list of all active selections. This list is kept sorted and non-overlapping.

    pub selections: SelectionVec,

    /// The DOM node this selection state applies to.

    pub node_id: DomNodeId,

}

impl SelectionState {

    /// Adds a new selection, merging it with any existing selections it overlaps with.

        // A full implementation would handle merging overlapping ranges.

        // For now, we simply add and sort for simplicity.

}

impl_option!(

    SelectionState,

    OptionSelectionState,

    copy = false,

    clone = false,

    [Debug, Clone, PartialEq]

);

// ============================================================================

// MULTI-CURSOR SUPPORT (Sublime Text style)

// ============================================================================

/// Stable identifier for a cursor/selection within a MultiCursorState.

///

/// Uses a monotonic u64 counter (not UUID) so it is `Copy` and C-API friendly.

/// Each SelectionId is unique within the lifetime of the process.

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]

#[repr(C)]

pub struct SelectionId {

    pub inner: u64,

}

impl SelectionId {

    /// Generate a new unique SelectionId.

        static COUNTER: AtomicU64 = AtomicU64::new(1);

}

/// Note: `Default` generates a new unique ID (increments global counter),

/// rather than returning a zero/sentinel value.

impl Default for SelectionId {

}

impl_option!(

    SelectionId,

    OptionSelectionId,

    [Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord]

);

impl_vec!(SelectionId, SelectionIdVec, SelectionIdVecDestructor, SelectionIdVecDestructorType, SelectionIdVecSlice, OptionSelectionId);

impl_vec_debug!(SelectionId, SelectionIdVec);

impl_vec_clone!(SelectionId, SelectionIdVec, SelectionIdVecDestructor);

impl_vec_partialeq!(SelectionId, SelectionIdVec);

impl_vec_partialord!(SelectionId, SelectionIdVec);

/// A selection (cursor or range) paired with a stable identity.

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

#[repr(C)]

pub struct IdentifiedSelection {

    pub id: SelectionId,

    pub selection: Selection,

}

impl_option!(

    IdentifiedSelection,

    OptionIdentifiedSelection,

    [Debug, Clone, Copy, PartialEq, Eq, Hash]

);

impl_vec!(IdentifiedSelection, IdentifiedSelectionVec, IdentifiedSelectionVecDestructor, IdentifiedSelectionVecDestructorType, IdentifiedSelectionVecSlice, OptionIdentifiedSelection);

impl_vec_debug!(IdentifiedSelection, IdentifiedSelectionVec);

impl_vec_clone!(IdentifiedSelection, IdentifiedSelectionVec, IdentifiedSelectionVecDestructor);

impl_vec_partialeq!(IdentifiedSelection, IdentifiedSelectionVec);

/// Multi-cursor state for a contenteditable element (Sublime Text style).

///

/// Replaces the split CursorManager + SelectionManager pattern for text editing.

/// Supports multiple simultaneous cursors/selections, each with a stable ID.

///

/// ## Invariants

///

/// - `selections` is sorted by position and non-overlapping.

/// - The **primary** selection is the last one added (highest index).

/// - After any mutation, `merge_overlapping()` is called to maintain invariants.

#[derive(Debug, Clone, PartialEq)]

pub struct MultiCursorState {

    /// Sorted by position, non-overlapping. Primary = last added (highest index).

    pub selections: Vec<IdentifiedSelection>,

    /// The DOM node this multi-cursor state applies to.

    pub node_id: DomNodeId,

    /// Stable key that survives DOM rebuilds (from `calculate_contenteditable_key`).

    pub contenteditable_key: u64,

}

impl MultiCursorState {

    /// Create a new MultiCursorState with a single cursor.

    /// Add a cursor, merging if it overlaps with existing selections.

    /// Returns the SelectionId of the new (or merged) cursor.

    #[must_use]

    /// Add a selection range, merging if it overlaps.

    /// Returns the SelectionId of the new (or merged) selection.

    #[must_use]

    /// Remove a selection by its stable ID. Returns true if found and removed.

    #[must_use]

    /// Get the primary selection (last added = highest index).

    /// Get a mutable reference to the primary selection.

    /// Get the primary cursor position (for scroll-into-view, IME, etc.)

    /// Convert to a Vec<Selection> for passing to `edit_text()`.

    /// Update selections from the result of `edit_text()`.

    ///

    /// Preserves existing IDs where possible (by index), assigns new IDs for extras.

        // Don't merge here — edit_text already returns correct positions

    /// Set all selections to a single cursor (e.g., on plain click without Ctrl).

        } else {

        };

    /// Set all selections to a single range.

        } else {

        };

    /// Number of active cursors/selections.

    /// Whether there are no selections (should not normally happen).

    /// Sort selections by position and merge any that overlap.

        // Sort by the start position of each selection

        // Merge overlapping: if selection[i+1] starts at or before selection[i] ends,

        // merge them into one range (keeping the later ID as it's more recent).

                    // Overlap — merge into one range covering both

                    // Keep the newer ID (the one being merged in)

        }

    /// Move all cursors using a movement function. Merges collisions afterward.

    ///

    /// `move_fn` takes a TextCursor and returns the new TextCursor after movement.

    /// If `extend_selection` is true, the anchor stays and only the focus moves,

    /// creating or extending a range.

                }

                }

            }

        }

    /// Remap the NodeId in `node_id` after DOM reconciliation.

    ///

    /// If the node was removed (not in the map), the multi-cursor state is cleared.

}

/// Helper: get the start position of a Selection for sorting.

        }

    }

/// Helper: get the end position of a Selection for merging.

        }

    }

// ============================================================================

// MULTI-NODE SELECTION (Browser-style Anchor/Focus model)

// ============================================================================

/// The anchor point of a text selection - where the user started selecting.

///

/// This is the fixed point during a drag operation. It records:

/// - The IFC root node (where the `UnifiedLayout` lives)

/// - The exact cursor position within that layout

/// - The visual bounds of the anchor character (for logical rectangle calculations)

///

/// The anchor remains constant during a drag; only the focus moves.

#[derive(Debug, Clone, PartialEq)]

pub struct SelectionAnchor {

    /// The IFC root node ID where selection started.

    /// This is the node that has `inline_layout_result` (e.g., `<p>`, `<div>`).

    pub ifc_root_node_id: NodeId,

    /// The exact cursor position within the IFC's `UnifiedLayout`.

    pub cursor: TextCursor,

    /// Visual bounds of the anchor character in viewport coordinates.

    /// Used for computing the logical selection rectangle during multi-line/multi-node selection.

    pub char_bounds: LogicalRect,

    /// The mouse position when the selection started (viewport coordinates).

    pub mouse_position: LogicalPosition,

}

/// The focus point of a text selection - where the selection currently ends.

///

/// This is the movable point during a drag operation. It updates on every mouse move.

#[derive(Debug, Clone, PartialEq)]

pub struct SelectionFocus {

    /// The IFC root node ID where selection currently ends.

    /// May differ from anchor's IFC root during cross-node selection.

    pub ifc_root_node_id: NodeId,

    /// The exact cursor position within the IFC's `UnifiedLayout`.

    pub cursor: TextCursor,

    /// Current mouse position in viewport coordinates.

    pub mouse_position: LogicalPosition,

}

/// Complete selection state spanning potentially multiple DOM nodes.

///

/// This implements the W3C Selection API model with anchor/focus endpoints.

/// The selection can span multiple IFC roots (e.g., multiple `<p>` elements).

///

/// ## Storage Model

///

/// Uses `BTreeMap<NodeId, SelectionRange>` for O(log N) lookup during rendering.

/// The key is the **IFC root NodeId**, and the value is the `SelectionRange` for that IFC.

///

/// ## Example

///

/// ```text

/// <p id="1">Hello [World</p>     <- Anchor in IFC 1, partial selection

/// <p id="2">Complete line</p>    <- InBetween, fully selected

/// <p id="3">Partial] end</p>     <- Focus in IFC 3, partial selection

/// ```

#[derive(Debug, Clone, PartialEq)]

pub struct TextSelection {

    /// The DOM this selection belongs to.

    pub dom_id: DomId,

    /// The anchor point - where the selection started (fixed during drag).

    pub anchor: SelectionAnchor,

    /// The focus point - where the selection currently ends (moves during drag).

    pub focus: SelectionFocus,

    /// Map from IFC root NodeId to the SelectionRange for that IFC.

    /// This allows O(log N) lookup during rendering.

    ///

    /// The `SelectionRange` contains the actual `TextCursor` positions for that IFC,

    /// ready to be passed to `UnifiedLayout::get_selection_rects()`.

    pub affected_nodes: BTreeMap<NodeId, SelectionRange>,

    /// Indicates whether anchor comes before focus in document order.

    /// True = forward selection (left-to-right), False = backward selection.

    pub is_forward: bool,

}

impl TextSelection {

    /// Create a new collapsed selection (cursor) at the given position.

        // For a collapsed selection, the anchor node has a zero-width range

    /// Check if this is a collapsed selection (cursor with no range).

    /// Get the selection range for a specific IFC root node.

    /// Returns `None` if this node is not part of the selection.

}

impl_option!(

    TextSelection,

    OptionTextSelection,

    copy = false,

    clone = false,

    [Debug, Clone, PartialEq]

);