//! DOM Reconciliation Module

//!

//! This module provides the reconciliation algorithm that compares two DOM trees

//! and generates lifecycle events. It uses stable keys and content hashing to

//! identify moves vs. mounts/unmounts.

//!

//! The reconciliation strategy is:

//! 1. **Stable Key Match:** If `.with_key()` is used, it's an absolute match (O(1)).

//! 2. **CSS ID Match:** If no key, use the CSS ID as key.

//! 3. **Structural Key Match:** nth-of-type-within-parent + parent's key (recursive).

//! 4. **Hash Match (Content Match):** Check for identical `DomNodeHash`.

//! 5. **Structural Hash Match:** For text nodes, match by structural hash (ignoring content).

//! 6. **Fallback:** Anything not matched is a `Mount` (new) or `Unmount` (old leftovers).

use alloc::{collections::BTreeMap, collections::VecDeque, string::{String, ToString}, vec::Vec};

use core::hash::Hash;

use azul_css::props::property::{CssPropertyType, RelayoutScope};

use crate::{

    dom::{DomId, DomNodeHash, DomNodeId, NodeData, NodeType, IdOrClass},

    events::{

        ComponentEventFilter, EventData, EventFilter, EventPhase, EventSource, EventType,

        LifecycleEventData, LifecycleReason, SyntheticEvent,

    },

    geom::LogicalRect,

    id::NodeId,

    styled_dom::{ChangedCssProperty, NodeHierarchyItemId, NodeHierarchyItem, RestyleResult, StyledNodeState},

    task::Instant,

    OrderedMap,

};

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

// NodeChangeSet — granular per-node change flags

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

/// Bit flags describing what changed about a node between old and new DOM.

/// Multiple flags can be set simultaneously. Uses manual bit manipulation

/// instead of bitflags crate to avoid adding a dependency.

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

pub struct NodeChangeSet {

    pub bits: u32,

}

impl NodeChangeSet {

    // --- Changes that affect LAYOUT (need relayout + repaint) ---

    /// Node type changed entirely (e.g., Text → Image).

    pub const NODE_TYPE_CHANGED: u32    = 0b0000_0000_0000_0001;

    /// Text content changed (for Text nodes).

    pub const TEXT_CONTENT: u32         = 0b0000_0000_0000_0010;

    /// CSS IDs or classes changed (may cause restyle → relayout).

    pub const IDS_AND_CLASSES: u32      = 0b0000_0000_0000_0100;

    /// Inline CSS properties changed that affect layout.

    pub const INLINE_STYLE_LAYOUT: u32  = 0b0000_0000_0000_1000;

    /// Children added, removed, or reordered.

    pub const CHILDREN_CHANGED: u32     = 0b0000_0000_0001_0000;

    /// Image source changed (may affect intrinsic size).

    pub const IMAGE_CHANGED: u32        = 0b0000_0000_0010_0000;

    /// Contenteditable flag changed.

    pub const CONTENTEDITABLE: u32      = 0b0000_0000_0100_0000;

    /// Tab index changed.

    pub const TAB_INDEX: u32            = 0b0000_0000_1000_0000;

    // --- Changes that affect PAINT only (no relayout needed) ---

    /// Inline CSS properties changed that affect paint only.

    pub const INLINE_STYLE_PAINT: u32   = 0b0000_0001_0000_0000;

    /// Styled node state changed (hover, active, focus, etc.).

    pub const STYLED_STATE: u32         = 0b0000_0010_0000_0000;

    // --- Changes that affect NEITHER layout nor paint ---

    /// Callbacks changed (new RefAny, different event handlers).

    pub const CALLBACKS: u32            = 0b0000_0100_0000_0000;

    /// Dataset changed.

    pub const DATASET: u32              = 0b0000_1000_0000_0000;

    /// Accessibility info changed.

    pub const ACCESSIBILITY: u32        = 0b0001_0000_0000_0000;

    // --- Composite masks ---

    /// Any change that requires a layout pass.

    pub const AFFECTS_LAYOUT: u32 = Self::NODE_TYPE_CHANGED

        | Self::TEXT_CONTENT

        | Self::IDS_AND_CLASSES

        | Self::INLINE_STYLE_LAYOUT

        | Self::CHILDREN_CHANGED

        | Self::IMAGE_CHANGED

        | Self::CONTENTEDITABLE;

    /// Any change that requires a paint/display-list update (but not layout).

    pub const AFFECTS_PAINT: u32 = Self::INLINE_STYLE_PAINT

        | Self::STYLED_STATE;

    /// Returns true if no visual change occurred (only callbacks/dataset/a11y).

    /// Returns true if layout is needed.

    /// Returns true if paint is needed (but not necessarily layout).

}

impl core::ops::BitOrAssign for NodeChangeSet {

}

impl core::ops::BitOr for NodeChangeSet {

    type Output = Self;

}

/// Extended diff result that includes per-node change information.

#[derive(Debug, Clone)]

pub struct ExtendedDiffResult {

    /// Original diff result (lifecycle events + node moves).

    pub diff: DiffResult,

    /// Per-node change report for matched (moved) nodes.

    /// Each entry: (old_node_id, new_node_id, what_changed).

    /// Only contains entries for nodes that were matched.

    pub node_changes: Vec<(NodeId, NodeId, NodeChangeSet)>,

}

impl Default for ExtendedDiffResult {

}

/// Compare two matched `NodeData` instances field-by-field and return

/// a `NodeChangeSet` describing what changed.

    // 1. Node type discriminant

    {

    // 2. Content-specific comparison (same discriminant)

        }

            // Use Hash-based comparison (pointer identity for decoded images,

            // callback identity for callback images)

            use core::hash::Hasher;

        }

    }

    // 3. IDs and classes (now stored in attributes as AttributeType::Id/Class)

    {

        use crate::dom::AttributeType;

    }

    // 4. Inline CSS properties — classify into layout-affecting vs paint-only.

    // After the inline-vs-component unification, inline CSS is stored as a `Css`

    // with rule blocks; iterate it via the `(property, conditions)` flat view to

    // keep the per-property compare semantics this code was written for.

        // Build a map of property type → (property, conditions) for old props.

        // Check new props against old.

                _ => {

                }

            }

        }

        // Check for removed properties

        }

    // 5. Callbacks

    {

            }

        }

    }

    // 6. Dataset

    // 7. Contenteditable

    // 8. Tab index

    // 9. Styled node state (hover, active, focused, etc.)

/// Calculate the reconciliation key for a node using the priority hierarchy:

/// 1. Explicit key (set via `.with_key()`)

/// 2. CSS ID (set via `.with_id("my-id")`)

/// 3. Structural key: nth-of-type-within-parent + parent's reconciliation key

///

/// The structural key prevents incorrect matching when nodes are inserted

/// before existing nodes (e.g., prepending items to a list) and allows

/// keyless nodes to be matched across frames when their logical position

/// and type are stable (even if content changed — which then fires an

/// `Update` lifecycle event, see `reconcile_dom`).

///

/// When `hierarchy` is empty (or this node has no entry), the structural

/// key degrades to `discriminant(node_type) + classes` — parent/nth-of-type

/// context simply drops out. This lets callers that don't track hierarchy

/// (tests, flat-DOM scenarios) still benefit from explicit-key and CSS-ID

/// matching without divergent behavior.

    use core::hash::Hasher;

    // Priority 1: Explicit key

    // Priority 2: CSS ID

    }

    // Priority 3: Structural key = (node type, classes, nth-of-type, parent key)

    }

            }

/// Precompute reconciliation keys for every node in a DOM tree.

///

/// Called once per side (old/new) at the start of `reconcile_dom`. Returns a

/// vector indexed by node index (`keys[node_id.index()]`) so lookup during

/// reconciliation is O(1).

/// Represents a mapping between a node in the old DOM and the new DOM.

#[derive(Debug, Clone, Copy)]

pub struct NodeMove {

    /// The NodeId in the old DOM array

    pub old_node_id: NodeId,

    /// The NodeId in the new DOM array

    pub new_node_id: NodeId,

}

/// The result of a DOM diff, containing lifecycle events and node mappings.

#[derive(Debug, Clone)]

pub struct DiffResult {

    /// Lifecycle events generated by the diff (Mount, Unmount, Resize, Update)

    pub events: Vec<SyntheticEvent>,

    /// Maps Old NodeId -> New NodeId for state migration (focus, scroll, etc.)

    pub node_moves: Vec<NodeMove>,

}

impl Default for DiffResult {

}

/// Calculates the difference between two DOM frames and generates lifecycle events.

///

/// This is the main entry point for DOM reconciliation. It compares the old and new

/// DOM trees and produces:

/// - Mount events for new nodes

/// - Unmount events for removed nodes

/// - Resize events for nodes whose bounds changed

/// - Update events for nodes whose logical position is stable but content changed

///

/// # Matching priority

/// For every node, the reconciliation key (`calculate_reconciliation_key`) encodes

/// Priority 1 (`.with_key()`), Priority 2 (CSS ID), and Priority 3 (structural key:

/// nth-of-type + parent key). The tiers are then tried in order:

///

/// 1. **Reconciliation key** — matches logical identity, may fire Update on content change.

/// 2. **Content hash** — exact match including content; catches pure reorders of anonymous nodes.

/// 3. **Structural hash** — matches node type + attrs ignoring text content; for text-edit cases.

///

/// # Arguments

/// * `old_node_data` / `new_node_data` - Per-node data for each frame

/// * `old_hierarchy` / `new_hierarchy` - Parent/sibling pointers. Pass `&[]` if unavailable;

///   the structural-key branch of the reconciliation key degrades gracefully.

/// * `old_layout` / `new_layout` - Layout bounds used to detect Resize events

/// * `dom_id` - The DOM identifier

/// * `timestamp` - Current timestamp for events

    // --- STEP 1: INDEX THE OLD DOM ---

    //

    // Three tiers, in priority order:

    //   Tier 1: reconciliation key (.with_key() / CSS ID / structural key)

    //   Tier 2: content hash (exact node_data hash — matches pure reorders)

    //   Tier 3: structural hash (discriminant + attrs, ignores text — matches text edits)

    //

    // Each tier is keyed with a `VecDeque<NodeId>` because all three can legitimately

    // collide (two sibling divs produce the same structural key, two identical nodes

    // produce the same content hash, etc.); we consume in document order on match.

    // --- STEP 2: ITERATE NEW DOM AND CLAIM MATCHES ---

    // Helper: pop the first non-consumed NodeId from a queue.

            }

        }

        // Tier 1: Reconciliation key (explicit `.with_key()`, CSS ID, or structural key)

        // An explicit `.with_key()` is a strong, intentional identity marker: if it

        // doesn't match anything in the old DOM we treat the new node as genuinely

        // new (Mount), rather than falling through to coarser content/structural

        // tiers and silently matching an unrelated node.

            // Tier 2: Content hash (exact match — catches pure reorders)

            // Tier 3: Structural hash (text-node fallback — ignores text content)

        // --- STEP 3: PROCESS MATCH OR MOUNT ---

            // FOUND A MATCH (It might be at a different index, but it's the "same" node)

            // Check for Resize

                // Fire Resize Event

            // Fire Update when the node was matched by logical identity (reconciliation

            // key: explicit .with_key(), CSS ID, or structural key) but its content hash

            // differs. Tier-2/Tier-3 matches by definition don't carry an Update — a

            // content-hash match is content-identical, and a structural-hash match is

            // a text edit handled by cursor/text reconciliation elsewhere.

        } else {

            // NO MATCH FOUND -> MOUNT (New Node)

        }

    }

    // --- STEP 4: CLEANUP (UNMOUNTS) ---

    // Any old node that wasn't claimed is effectively destroyed.

    }

/// Creates a lifecycle event with all necessary fields.

/// Check if the node has an AfterMount callback registered.

            EventFilter::Component(ComponentEventFilter::AfterMount)

        )

/// Check if the node has a BeforeUnmount callback registered.

            EventFilter::Component(ComponentEventFilter::BeforeUnmount)

        )

/// Check if the node has a NodeResized callback registered.

            EventFilter::Component(ComponentEventFilter::NodeResized)

        )

/// Check if the node has any lifecycle callback that would respond to updates.

            EventFilter::Component(ComponentEventFilter::Updated)

        )

/// Migrate state (focus, scroll, etc.) from old node IDs to new node IDs.

///

/// This function should be called after reconciliation to update any state

/// that references old NodeIds to use the new NodeIds.

///

/// # Example

/// ```rust,ignore

/// let diff = reconcile_dom(...);

/// let migration_map = create_migration_map(&diff.node_moves);

/// 

/// // Migrate focus

/// if let Some(current_focus) = focus_manager.focused_node {

///     if let Some(&new_id) = migration_map.get(&current_focus) {

///         focus_manager.focused_node = Some(new_id);

///     } else {

///         // Focused node was unmounted, clear focus

///         focus_manager.focused_node = None;

///     }

/// }

/// ```

/// Executes state migration between the old DOM and the new DOM based on diff results.

///

/// This iterates through matched nodes. If a match has BOTH a merge callback AND a dataset,

/// it executes the callback to transfer state from the old node to the new node.

///

/// This must be called **before** the old DOM is dropped, because we need to access its data.

///

/// # Arguments

/// * `old_node_data` - Mutable reference to the old DOM's node data (source of heavy state)

/// * `new_node_data` - Mutable reference to the new DOM's node data (target for heavy state)

/// * `node_moves` - The matched nodes from the reconciliation diff

///

/// # Example

/// ```rust,ignore

/// let diff_result = reconcile_dom(&old_data, &new_data, ...);

/// 

/// // Execute state migration BEFORE old_dom is dropped

/// transfer_states(&mut old_data, &mut new_data, &diff_result.node_moves);

/// 

/// // Now safe to drop old_dom - heavy resources have been transferred

/// drop(old_dom);

/// ```

    use crate::refany::OptionRefAny;

        // Bounds check

        // 1. Check if the NEW node has requested a merge callback

        };

        // 2. Check if BOTH nodes have datasets

        // We need to temporarily take the datasets to satisfy borrow checker

                // One or both datasets missing - restore what we had

            }

        }

    }

/// Calculate a stable key for a contenteditable node using the hierarchy:

///

/// 1. **Explicit Key** - If `.with_key()` was called, use that

/// 2. **CSS ID** - If the node has a CSS ID (e.g., `#my-editor`), hash that

/// 3. **Structural Key** - Hash of `(nth-of-type, parent_key)` recursively

///

/// The structural key prevents shifting when elements are inserted before siblings.

/// For example, in `<div><p>A</p><p contenteditable>B</p></div>`, if we insert

/// a new `<p>` at the start, the contenteditable `<p>` becomes nth-child(3) but

/// its nth-of-type stays stable (it's still the 2nd `<p>`).

///

/// # Arguments

/// * `node_data` - All nodes in the DOM

/// * `hierarchy` - Parent-child relationships

/// * `node_id` - The node to calculate the key for

///

/// # Returns

/// A stable u64 key for the node

    use core::hash::Hasher;

    // Priority 1: Explicit key (from .with_key())

    // Priority 2: CSS ID

    }

    // Priority 3: Structural key = (nth-of-type, classes, parent_key)

    // Get parent and calculate its key recursively

    } else {

    };

    // Calculate nth-of-type (count siblings of same node type before this one)

    // We compare discriminants directly without hashing

        // Count siblings with same node type that come before this node

        }

    } else {

    };

    // Hash the node type discriminant (Discriminant<T> implements Hash)

    // Also hash the classes for additional stability

    }

/// Reconcile cursor byte position when text content changes.

///

/// This function maps a cursor position from old text to new text, preserving

/// the cursor's logical position as much as possible:

///

/// 1. If cursor is in unchanged prefix → stays at same byte offset

/// 2. If cursor is in unchanged suffix → adjusts by length difference

/// 3. If cursor is in changed region → places at end of new content

///

/// # Arguments

/// * `old_text` - The previous text content

/// * `new_text` - The new text content

/// * `old_cursor_byte` - Cursor byte offset in old text

///

/// # Returns

/// The reconciled cursor byte offset in new text

///

/// # Example

/// ```rust,ignore

/// let old_text = "Hello";

/// let new_text = "Hello World";

/// let old_cursor = 5; // cursor at end of "Hello"

/// let new_cursor = reconcile_cursor_position(old_text, new_text, old_cursor);

/// assert_eq!(new_cursor, 5); // cursor stays at same position (prefix unchanged)

/// ```

    // If texts are equal, cursor is unchanged

    // Empty old text - place cursor at end of new text

    // Empty new text - place cursor at 0

    // Find common prefix (how many bytes from the start are identical)

    // If cursor was in the unchanged prefix, it stays at the same byte offset

    // Find common suffix (how many bytes from the end are identical)

    // Calculate where the suffix starts in old and new text

    // If cursor was in the unchanged suffix, adjust by length difference

    // Cursor was in the changed region - place at end of inserted content

    // This handles insertions (cursor moves with new text) and deletions (cursor at edit point)

/// Get the text content from a NodeData if it's a Text node.

///

/// Returns the text string if the node is `NodeType::Text`, otherwise `None`.

    } else {

    }

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

// ChangeAccumulator — unifies all change input paths

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

/// Text change info for cursor/selection reconciliation.

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

pub struct TextChange {

    /// The text content before the change.

    pub old_text: String,

    /// The text content after the change.

    pub new_text: String,

}

/// Per-node change report combining multiple information sources.

#[derive(Debug, Clone, Default)]

pub struct NodeChangeReport {

    /// Bitflags from DOM-level field comparison.

    pub change_set: NodeChangeSet,

    /// Highest RelayoutScope from any CSS property that changed on this node.

    /// This is more granular than NodeChangeSet's binary LAYOUT/PAINT split.

    ///

    /// - `None` → repaint only (color, opacity, transform)

    /// - `IfcOnly` → reshape text in the containing IFC

    /// - `SizingOnly` → recompute this node's intrinsic size

    /// - `Full` → full subtree relayout (display, position, float, etc.)

    pub relayout_scope: RelayoutScope,

    /// Individual CSS properties that changed (for fine-grained cache invalidation).

    /// Empty if the change was structural (text content, node type, etc.)

    pub changed_css_properties: Vec<CssPropertyType>,

    /// If text content changed, the old and new text for cursor reconciliation.

    pub text_change: Option<TextChange>,

}

impl NodeChangeReport {

    /// Returns the DirtyFlag level needed for this change report.

    /// Maps RelayoutScope + NodeChangeSet → a simple tri-state.

}

/// Unified change report that merges information from all three change paths:

///

/// 1. **DOM reconciliation** (`compute_node_changes` after `reconcile_dom`)

/// 2. **CSS restyle** (`restyle_on_state_change` for hover/focus/active)

/// 3. **Runtime edits** (`words_changed`, `css_properties_changed`, `images_changed`)

///

/// This is the single source of truth for "what work needs to happen this frame".

#[derive(Debug, Clone, Default)]

pub struct ChangeAccumulator {

    /// Per-node change info. Key is the new-DOM NodeId.

    pub per_node: BTreeMap<NodeId, NodeChangeReport>,

    /// Maximum RelayoutScope across all changed nodes.

    /// Quick check: if this is `None`, we can skip layout entirely.

    pub max_scope: RelayoutScope,

    /// Nodes that are newly mounted (no old counterpart).

    /// These always need full layout.

    pub mounted_nodes: Vec<NodeId>,

    /// Nodes that were unmounted (no new counterpart).

    /// Used for cleanup (remove from scroll/focus/cursor managers).

    pub unmounted_nodes: Vec<NodeId>,

}

impl ChangeAccumulator {

    /// Returns true if no changes were detected at all.

    /// Returns true if layout work is needed (any node has scope > None).

    /// Returns true if only paint work is needed (no layout).

    /// Returns true if only non-visual changes occurred (callbacks, dataset, a11y).

    /// Add a node change from DOM reconciliation (Path A).

    /// Add a text change (from runtime edit or DOM reconciliation).

    /// Add a CSS property change (from runtime edit or restyle).

    /// Add an image change (from runtime edit or DOM reconciliation).

    /// Add a mounted (new) node.

    /// Add an unmounted (removed) node.

    /// Merge a `RestyleResult` (from `restyle_on_state_change()`) into this accumulator.

    ///

    /// This is the bridge between Path B (restyle) and the unified change pipeline.

    /// Each `ChangedCssProperty` is classified via `relayout_scope()` to determine

    /// whether it affects layout or only paint.

        }

    /// Populate this accumulator from an `ExtendedDiffResult` + the old/new DOM data.

    ///

    /// This converts per-node `NodeChangeSet` flags into full `NodeChangeReport`s

    /// with `RelayoutScope` classification.

            // Determine RelayoutScope from the change flags

            // Extract text change info if TEXT_CONTENT flag is set

            } else {

            };

        }

        // Track mounts: new nodes that didn't match anything in old

        }

        // Track unmounts: old nodes that didn't match anything in new

        }

    /// Classify a NodeChangeSet into the appropriate RelayoutScope.

        // NODE_TYPE_CHANGED or CHILDREN_CHANGED → Full

        {

        // IDS_AND_CLASSES → Full (conservative: class change may add layout-affecting CSS)

        // INLINE_STYLE_LAYOUT → could be IfcOnly, SizingOnly, or Full

        // We need to check individual properties for the exact scope.

        // For now, we use SizingOnly as a conservative default since

        // the individual property scopes were already checked in compute_node_changes.

            // Walk the inline CSS properties to find the max scope

            }

            } else {

            };

        // TEXT_CONTENT → IfcOnly (reshape text, may cascade)

        // IMAGE_CHANGED → SizingOnly (intrinsic size may change)

        // CONTENTEDITABLE → SizingOnly