//! Text editing changeset system

//!

//! **STATUS:** The core types (`TextChangeset`, `TextOperation`, `TextOp*` structs) are

//! actively used by `window.rs`, `undo_redo.rs`, `event.rs`, and platform code. The

//! `create_*_changeset` free functions are not yet wired into event handling.

//!

//! ## Architecture

//!

//! This module implements a two-phase changeset system for all text editing operations:

//! 1. **Create changesets** (pre-callback): Analyze what would change, don't mutate yet

//! 2. **Apply changesets** (post-callback): Actually mutate state if !preventDefault

//!

//! This pattern enables:

//! - preventDefault support for ALL operations (not just text input)

//! - Undo/redo stack (record changesets before applying)

//! - Validation (check bounds, permissions before mutation)

//! - Inspection (user callbacks can see planned changes)

use azul_core::{

    dom::DomNodeId,

    selection::{OptionSelectionRange, SelectionRange},

    task::Instant,

    window::CursorPosition,

};

use azul_css::AzString;

use crate::managers::selection::ClipboardContent;

/// Unique identifier for a changeset (for undo/redo)

pub type ChangesetId = usize;

/// A text editing changeset that can be inspected before application

#[derive(Debug, Clone)]

#[repr(C)]

pub struct TextChangeset {

    /// Unique ID for undo/redo tracking

    pub id: ChangesetId,

    /// Target DOM node

    pub target: DomNodeId,

    /// The operation to perform

    pub operation: TextOperation,

    /// When this changeset was created

    pub timestamp: Instant,

}

/// Insert text at cursor position

#[derive(Debug, Clone)]

#[repr(C)]

pub struct TextOpInsertText {

    pub text: AzString,

    pub position: CursorPosition,

    pub new_cursor: CursorPosition,

}

/// Delete text in range

#[derive(Debug, Clone)]

#[repr(C)]

pub struct TextOpDeleteText {

    pub range: SelectionRange,

    pub deleted_text: AzString,

    pub new_cursor: CursorPosition,

}

/// Replace text in range with new text

#[derive(Debug, Clone)]

#[repr(C)]

pub struct TextOpReplaceText {

    pub range: SelectionRange,

    pub old_text: AzString,

    pub new_text: AzString,

    pub new_cursor: CursorPosition,

}

/// Set selection to new range

#[derive(Debug, Clone)]

#[repr(C)]

pub struct TextOpSetSelection {

    pub old_range: OptionSelectionRange,

    pub new_range: SelectionRange,

}

/// Extend selection in a direction

#[derive(Debug, Clone)]

#[repr(C)]

pub struct TextOpExtendSelection {

    pub old_range: SelectionRange,

    pub new_range: SelectionRange,

    pub direction: SelectionDirection,

}

/// Clear all selections

#[derive(Debug, Clone)]

#[repr(C)]

pub struct TextOpClearSelection {

    pub old_range: SelectionRange,

}

/// Move cursor to new position

#[derive(Debug, Clone)]

#[repr(C)]

pub struct TextOpMoveCursor {

    pub old_position: CursorPosition,

    pub new_position: CursorPosition,

    pub movement: CursorMovement,

}

/// Copy selection to clipboard (no text change)

#[derive(Debug, Clone)]

#[repr(C)]

pub struct TextOpCopy {

    pub range: SelectionRange,

    pub content: ClipboardContent,

}

/// Cut selection to clipboard (deletes text)

#[derive(Debug, Clone)]

#[repr(C)]

pub struct TextOpCut {

    pub range: SelectionRange,

    pub content: ClipboardContent,

    pub new_cursor: CursorPosition,

}

/// Paste from clipboard (inserts text)

#[derive(Debug, Clone)]

#[repr(C)]

pub struct TextOpPaste {

    pub content: ClipboardContent,

    pub position: CursorPosition,

    pub new_cursor: CursorPosition,

}

/// Select all text in node

#[derive(Debug, Clone)]

#[repr(C)]

pub struct TextOpSelectAll {

    pub old_range: OptionSelectionRange,

    pub new_range: SelectionRange,

}

/// Text editing operation (what will change)

#[derive(Debug, Clone)]

#[repr(C, u8)]

pub enum TextOperation {

    /// Insert text at cursor position

    InsertText(TextOpInsertText),

    /// Delete text in range

    DeleteText(TextOpDeleteText),

    /// Replace text in range with new text

    ReplaceText(TextOpReplaceText),

    /// Set selection to new range

    SetSelection(TextOpSetSelection),

    /// Extend selection in a direction

    ExtendSelection(TextOpExtendSelection),

    /// Clear all selections

    ClearSelection(TextOpClearSelection),

    /// Move cursor to new position

    MoveCursor(TextOpMoveCursor),

    /// Copy selection to clipboard (no text change)

    Copy(TextOpCopy),

    /// Cut selection to clipboard (deletes text)

    Cut(TextOpCut),

    /// Paste from clipboard (inserts text)

    Paste(TextOpPaste),

    /// Select all text in node

    SelectAll(TextOpSelectAll),

}

/// Re-export from events module

pub use azul_core::events::SelectionDirection;

/// Type of cursor movement

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

#[repr(C)]

pub enum CursorMovement {

    /// Move left one character

    Left,

    /// Move right one character

    Right,

    /// Move up one line

    Up,

    /// Move down one line

    Down,

    /// Jump to previous word boundary

    WordLeft,

    /// Jump to next word boundary

    WordRight,

    /// Jump to start of line

    LineStart,

    /// Jump to end of line

    LineEnd,

    /// Jump to start of document

    DocumentStart,

    /// Jump to end of document

    DocumentEnd,

    /// Absolute position (not relative)

    Absolute,

}

impl TextChangeset {

    /// Create a new changeset with unique ID

        use std::sync::atomic::{AtomicUsize, Ordering};

        static CHANGESET_ID_COUNTER: AtomicUsize = AtomicUsize::new(0);

    /// Check if this changeset actually mutates text (vs just selection/cursor)

            TextOperation::InsertText { .. }

                | TextOperation::DeleteText { .. }

                | TextOperation::ReplaceText { .. }

                | TextOperation::Cut { .. }

                | TextOperation::Paste { .. }

        )

    /// Check if this changeset changes selection (including cursor moves)

            TextOperation::SetSelection { .. }

                | TextOperation::ExtendSelection { .. }

                | TextOperation::ClearSelection { .. }

                | TextOperation::MoveCursor { .. }

                | TextOperation::SelectAll { .. }

        )

    /// Check if this changeset involves clipboard

            TextOperation::Copy { .. } | TextOperation::Cut { .. } | TextOperation::Paste { .. }

        )

    /// Get the target cursor position after this changeset is applied

        }

    /// Get the target selection range after this changeset is applied

        }

}

/// Creates a copy changeset from the current selection.

///

/// Extracts the selected text content and creates a `TextChangeset` with a `Copy`

/// operation. Returns `None` if there is no selection or no content to copy.

    // Extract clipboard content from current selection

    // Get selection range for changeset

/// Creates a cut changeset from the current selection.

///

/// Extracts the selected text content and creates a `TextChangeset` with a `Cut`

/// operation that will delete the selected text after copying it to clipboard.

/// Returns `None` if there is no selection or no content to cut.

    // Extract clipboard content from current selection

    // Get selection range for changeset

    // The logical cursor will be at the start of the deleted range

    // SelectionManager will map this to physical coordinates

/// Creates a paste changeset at the current cursor position.

///

/// Note: The actual clipboard content must be provided by the caller (typically

/// `event_v2.rs`), as clipboard access is platform-specific and not available

/// in the layout engine. This function currently returns `None` and paste

/// operations are initiated from `event_v2.rs` with pre-read clipboard content.

    // Paste is handled by event_v2.rs with clipboard content parameter.

    // This stub exists for API consistency with other changeset creators.

/// Creates a select-all changeset for the target node.

///

/// Selects all text content in the target node from the beginning to the end.

/// Returns `None` if the node has no text content.

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

    // Get current selection (if any) for undo

    // Get the text content to determine end position

    // Create selection range from start to end of text

/// Creates a delete changeset for the current selection or single character.

///

/// If there is an active selection, deletes the entire selection.

/// If there is only a cursor (no selection), deletes a single character:

/// - `forward = true` (Delete key): deletes the character after the cursor

/// - `forward = false` (Backspace): deletes the character before the cursor

///

/// Returns `None` if there is nothing to delete (e.g., cursor at document boundary).

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

    // Get current selection/cursor

    // Determine what to delete

        // Selection exists - delete the selection

        // Extract the text in the range

        // For now, simplified: delete entire selection

        // TODO: Actually extract text between range.start and range.end

        // No selection - delete one character

            // Delete key - delete character after cursor

            // Delete one character forward

        } else {

            // Backspace - delete character before cursor

            // Delete one character backward

        };

    } else {

    };

    // New cursor position after deletion (at start of deleted range)