#[allow(clippy::wildcard_imports)] // widget/render module pulls in the css property/value types it builds with

use super::*;

use std::collections::HashMap;

use azul_core::geom::{LogicalPosition, LogicalRect, LogicalSize};

use azul_core::resources::RendererResources;

use azul_css::props::basic::{ColorU, FontRef};

use azul_css::props::basic::pixel::DEFAULT_FONT_SIZE;

use azul_css::props::style::filter::StyleFilter;

use agg_rust::blur::stack_blur_rgba32;

use agg_rust::rendering_buffer::RowAccessor;

use agg_rust::trans_affine::TransAffine;

use crate::glyph_cache::GlyphCache;

use crate::solver3::display_list::{BorderRadius, DisplayList, DisplayListItem, LocalScrollId};

use crate::text3::cache::FontManager;

const IDENTITY_EPSILON: f32 = 0.0001;

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

// Retained-Mode Compositor — Layer Tree

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

/// Unique identifier for a compositing layer.

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

pub struct LayerId(pub u64);

/// Persistent compositor state across frames.

///

/// Holds a tree of `Layer`s, each with its own pixbuf. On incremental updates

/// only damaged layers are re-rendered, and scroll is handled by pixel-shift.

#[derive(Debug)]

pub struct CompositorState {

    /// All layers keyed by ID.

    pub layers: HashMap<LayerId, Layer>,

    /// Root layer of the tree.

    pub root_layer: LayerId,

    /// Monotonic counter for generating unique `LayerIds`.

    next_layer_id: u64,

    /// Previous frame's per-node positions, used for damage computation.

    pub previous_positions: Vec<LogicalPosition>,

}

/// A single compositing layer with its own pixel buffer.

#[derive(Debug)]

pub struct Layer {

    pub id: LayerId,

    /// Persistent RGBA buffer for this layer's content.

    pub pixbuf: AzulPixmap,

    /// Position and size in parent layer coordinates.

    pub bounds: LogicalRect,

    /// Dirty regions that need re-rendering this frame.

    pub damage: Vec<LogicalRect>,

    /// Child layers in z-order (bottom to top).

    pub children: Vec<LayerId>,

    /// Current scroll offset (for scroll-frame layers).

    pub scroll_offset: (f32, f32),

    /// Layer opacity (1.0 = fully opaque).

    pub opacity: f32,

    /// CSS filters applied at composite time. For a normal filter layer these

    /// are applied to the layer's OWN content; for a `backdrop-filter` layer

    /// (see `is_backdrop_filter`) they are instead applied to the already-

    /// composited backdrop pixels under the layer's bounds.

    pub filters: Vec<StyleFilter>,

    /// If true, `filters` apply to the backdrop (parent + earlier siblings

    /// already in `output`), not to this layer's own content.

    pub is_backdrop_filter: bool,

    /// CSS transform for this layer.

    pub transform: TransAffine,

    /// Range of display list items [start, end) that render into this layer.

    pub display_list_range: (usize, usize),

    /// If this layer is a scroll frame, the scroll ID.

    pub scroll_id: Option<LocalScrollId>,

    /// Whether this layer needs re-compositing onto its parent.

    pub composite_dirty: bool,

}

/// Reason a layer was created.

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

pub enum LayerReason {

    /// Root layer (always exists).

    Root,

    /// Created for a `PushScrollFrame`.

    ScrollFrame,

    /// Created for a `PushFilter` containing blur.

    BlurFilter,

    /// Created for a `PushOpacity` with opacity < 1.0.

    Opacity,

    /// Created for a `PushReferenceFrame` with non-identity transform.

    Transform,

}

impl CompositorState {

    /// Create a new compositor with a root layer sized to the viewport.

    #[allow(clippy::cast_precision_loss)] // bounded pixel/coord/colour/glyph cast

        );

    /// Allocate a new unique layer ID.

    /// Read-only peek at the next layer ID counter (for leak probes).

    /// Walk the display list and create layers for scroll frames, filters, opacity, transforms.

    /// Returns a mapping from display-list item index to the `LayerId` it should render into.

    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] // bounded pixel/coord/colour/glyph cast

    #[allow(clippy::too_many_lines)] // large but cohesive: single-purpose layout/render/parse routine (one branch per case)

    /// # Panics

    ///

    /// Panics if the internal layer stack underflows (a malformed display list).

    // single-pass walk over the full display-list opcode set; splitting it would

    // only scatter the shared layer-stack state across helpers

    #[allow(clippy::cognitive_complexity)]

        // Remove all non-root layers from previous frame

                DisplayListItem::PushScrollFrame {

                    ..

                } => {

                        // Find the matching PopScrollFrame to set range

                        // Add as child of current parent

                }

                DisplayListItem::PopScrollFrame => {

                }

                }

                DisplayListItem::PopOpacity => {

                    // Only pop if the top layer was an opacity layer

                }

                }

                DisplayListItem::PopFilter => {

                }

                DisplayListItem::PushReferenceFrame {

                    ..

                } => {

                }

                DisplayListItem::PopReferenceFrame => {

                }

                // `backdrop-filter` (superplan g4): allocate a layer mirroring

                // PushFilter, but tagged `is_backdrop_filter` so the compositor

                // applies the filter to the *backdrop* (parent + earlier siblings

                // already in `output`) rather than to the layer's own content.

                // The compositing side reads back the `output` region under the

                // layer bounds and runs `apply_layer_filters` on it before

                // blitting the content (see `composite_layer_recursive`).

                        // The layer's OWN content may be empty (e.g. an empty

                        // div with only `backdrop-filter`). render_layers skips

                        // empty display-list ranges, leaving the Layer::new

                        // opaque-white pixbuf, which would then be blitted over

                        // (and wipe) the filtered backdrop. Start transparent so

                        // an empty backdrop-filter element shows the backdrop.

                }

                DisplayListItem::PopBackdropFilter => {

                }

                // `text-shadow` (Push/PopTextShadow) is a text-rasterization

                // concern, not a layer boundary, so it is handled in

                // `render_single_item`, not here.

            }

        }

    /// Compute damage rects from dirty node sets and old/new positions.

            // Old bounds

            // New bounds

        }

        // Distribute damage rects to affected layers

            }

        }

    /// Render display list items into their respective layer pixbufs.

    /// # Panics

    ///

    /// Panics if a referenced layer id is not present in the layer map.

    /// # Errors

    ///

    /// Returns an error string if the layers cannot be composited.

        // Collect layer IDs, ranges, bounds, scroll_id and child ranges.

                // Ranges of this layer's DIRECT children (nested scroll frames /

                // opacity / transform groups). They render into their own

                // pixbufs, so they must be skipped when rendering this layer's

                // range (which, for the root, spans the whole display list).

        #[cfg(feature = "std")]

            // This layer's scroll offset (0 for non-scroll layers). Content inside

            // a scroll frame is at absolute coords; the renderer draws at

            // `pos - seed`, so folding the scroll offset into the seed shifts the

            // frame's content within its own pixbuf. composite_frame blits the

            // pixbuf back at `layer.bounds.origin` (NOT scroll_offset), so applying

            // it here is the single place — no double offset. (Without this, a full

            // repaint while scrolled drew content at offset 0.)

            // Clear the layer pixbuf (transparent for non-root, white for root)

            // Seed = layer origin (for pixbuf-local placement) + scroll offset.

        }

    /// Composite all layers bottom-up into the final output pixmap.

        // Start from root layer

    #[allow(clippy::cast_possible_truncation)] // bounded pixel/coord/colour/glyph cast

        };

        // For root layer, just blit directly

                // Apply filters at composite time (to the layer's own content).

                } else {

                };

            }

        }

        // Composite children in z-order

                } else {

                },

                } else {

                },

            );

        }

    /// Handle scroll by shifting pixels and re-rendering the exposed strip.

    #[allow(clippy::cast_possible_truncation)] // bounded pixel/coord/colour/glyph cast

    #[allow(clippy::similar_names)] // domain-standard coordinate/geometry/short-lived names

    /// # Panics

    ///

    /// Panics if `layer_id` is not present in the layer map.

    /// # Errors

    ///

    /// Returns an error string if the layer cannot be scrolled.

        // Find the layer with this scroll_id

        };

        // Shift pixels

        // Compute exposed strips and re-render them.

        // Diagonal scroll produces 2 rects (one vertical strip + one horizontal strip).

        // Re-render damaged regions

        // Child-layer ranges to skip (rendered separately) — same as render_layers.

        // Scroll fast-path: VirtualView content (separate child DOMs) isn't

        // re-composited here — an empty state suffices (VirtualViews inside a

        // scrolling region are an edge case; the next full repaint composites them).

}

impl Layer {

        Self {

            opacity: 1.0,

            is_backdrop_filter: false,

            composite_dirty: true,

        }

}

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

// Layer helper types and functions

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

/// Which Push/Pop pair to match.

#[derive(Clone, Copy)]

enum MatchKind {

    ScrollFrame,

    Opacity,

    Filter,

    BackdropFilter,

    ReferenceFrame,

}

/// Find the matching Pop for a given Push at index `start`.

#[allow(clippy::match_same_arms)] // enum/value mapping/dispatch table: one arm per input variant (or cross-type bindings that can't merge)

            (DisplayListItem::PopScrollFrame, MatchKind::ScrollFrame) => {

            }

            (DisplayListItem::PopOpacity, MatchKind::Opacity) => {

            }

            (DisplayListItem::PopFilter, MatchKind::Filter) => {

            }

            (DisplayListItem::PopBackdropFilter, MatchKind::BackdropFilter) => {

            }

            (DisplayListItem::PopReferenceFrame, MatchKind::ReferenceFrame) => {

            }

        }

    }

/// Compute exposed rectangles after a scroll of (dx, dy) in logical coords.

/// Returns 0, 1, or 2 rects: a vertical strip (top/bottom) and/or a horizontal

/// strip (left/right). Diagonal scrolling produces both strips.

    // Vertical exposed strip (full width, covers top or bottom edge)

            // Scrolled down — top strip exposed

        } else {

            // Scrolled up — bottom strip exposed

        };

    // Horizontal exposed strip (full height, covers left or right edge)

        } else {

        };

/// Scroll a frame's clip region by *moving the pixels already on screen* and

/// return the newly-exposed strip(s) (logical coords) that still need painting.

///

/// This is the thin-strip optimisation for scrolling: instead of repainting the

/// whole `clip_bounds` viewport every frame, we `memmove` the pixels that are

/// still visible and only re-rasterise the strip that scrolled into view. For a

/// 30px scroll of a 200×100 viewport that turns ~20k painted px into ~6k.

///

/// Sign convention is the renderer's, NOT the legacy `compute_exposed_rects`:

/// `render_single_item`/`scroll_rect` draw a content item at `position - offset`,

/// so a *positive* `delta` (the user scrolled further down/right) moves on-screen

/// content UP/LEFT. We therefore move the existing pixels UP/LEFT and expose a

/// strip at the trailing (bottom/right) edge. `compute_exposed_rects` assumed the

/// inverse and never matched the renderer — it and `scroll_layer` are dead code.

///

/// Only pixels strictly inside the (clamped) clip rectangle are moved, so the

/// scrollbar, the parent background and sibling content outside the frame are

/// left untouched. Diagonal scroll (both axes in one frame — mobile pan) is

/// handled as TWO strips: the vertical move + horizontal move are separable 1-D

/// passes, so the net effect is a 2-D translation and the exposed region is an

/// L-shape (a full-width top/bottom strip + a full-height left/right strip).

/// The two strips overlap in one corner; that corner is simply repainted twice,

/// which is correct (the caller clears then renders each item once).

///

/// Returns an empty vec when nothing moved, or `[clip_bounds]` when the shift is

/// large enough that the whole viewport is exposed (caller repaints in full).

///

/// NOTE: the move copies *composited* pixels, so a scroll frame whose content is

/// not opaque over its clip can drag whatever showed through. Real scroll

/// containers paint an opaque background or fully cover their box, so this is a

/// known, documented limitation rather than a correctness bug for the common case.

#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap, clippy::cast_precision_loss)] // bounded pixel/coord/colour/glyph cast

#[allow(clippy::similar_names)] // domain-standard coordinate/geometry/short-lived names

    // Physical shift = difference of the ROUNDED offsets, not the rounded

    // difference. Rounding each frame's delta independently accumulates up to

    // 0.5px of error per step at fractional dpi (the moved block drifts away

    // from the freshly-rasterised strips, showing internal seams); anchoring

    // both ends to the absolute offset keeps the cumulative error ≤ 1px

    // forever: round(new·dpi) − round(prev·dpi) telescopes across frames.

    // Nothing actually moved (sub-pixel jitter rounds to zero).

    // Clip rectangle in physical pixels, clamped to the pixmap.

    // Shift exceeds the region — every pixel is exposed, so skip the memmove and

    // let the caller repaint the whole clip.

    // Dispatch to a specialised mover. The common single-axis cases get a tight

    // 1-D pass; diagonal pan gets a SINGLE-pass 2-D move (each row copied once

    // from its diagonally-offset source) instead of two sequential full passes —

    // half the memory traffic. (no-op is already handled by the early return.)

    }

    // Exposed strip(s) in LOGICAL coords. Over-cover the moving edge by one

    // physical pixel so dpi rounding never leaves a 1px white seam between the

    // moved block and the freshly-painted strip. One strip per moved axis, so

    // diagonal pan yields two (an L-shape, overlapping in one corner).

    //

    // Strips are derived from the CLAMPED region (`cx0..cx1`/`cy0..cy1`, the

    // pixels the memmove actually touched), not the raw `clip_bounds`. When

    // the clip extends past the pixmap (container taller than the window),

    // the raw clip's trailing edge is off-screen — a strip placed there

    // clamps to nothing, nothing repaints, and the rows at the WINDOW edge

    // keep their pre-shift content: a stale duplicated band that gets

    // re-dragged on every subsequent scroll.

            // bottom strip exposed

        } else {

            // top strip exposed

        };

            // right strip exposed

        } else {

            // left strip exposed

        };

// --- scroll_shift_region movers -------------------------------------------

// All three operate in PHYSICAL pixels on the raw RGBA buffer. `cx0..cx1` /

// `cy0..cy1` is the clamped clip region; `stride_px` is the buffer width in

// pixels. They only ever touch bytes inside the clip rectangle. Sign of the

// `px_*` deltas follows the renderer: positive = content moves up/left, so the

// exposed strip is the trailing (bottom/right) edge.

/// Single-axis VERTICAL move: shift whole rows up (`px_dy>0`) or down (`px_dy`<0).

/// Iteration order is chosen so a row read as a source is never already

/// overwritten (src and dst row SETS overlap, so order matters).

#[inline]

#[allow(clippy::cast_sign_loss)] // bounded pixel/coord/colour/glyph cast

#[allow(clippy::similar_names)] // domain-standard coordinate/geometry/short-lived names

        // Content up: dst = src - px_dy (dst < src) → iterate top→bottom.

    } else {

        // Content down: dst = src + amt (dst > src) → iterate bottom→top.

    }

/// Single-axis HORIZONTAL move: shift each row's pixels left (`px_dx>0`) or right

/// (`px_dx`<0). Source and dest overlap WITHIN a row, so `copy_within`'s memmove

/// semantics handle it directly — no per-row ordering needed.

#[inline]

#[allow(clippy::cast_sign_loss)] // bounded pixel/coord/colour/glyph cast

#[allow(clippy::similar_names)] // domain-standard coordinate/geometry/short-lived names

    } else {

    }

/// Diagonal (two-axis) pan in ONE pass: each destination row is copied directly

/// from its diagonally-offset source row, applying the column shift in the same

/// `copy_within`. Because |`px_dy`| ≥ 1, the source and dest rows are always

/// DIFFERENT rows ≥ one stride apart, so the per-copy byte ranges never overlap

/// regardless of the horizontal direction — only the row iteration order (by

/// `px_dy` sign) matters, exactly as in the vertical case. This does the work of

/// the two 1-D passes with half the memory traffic.

#[inline]

#[allow(clippy::cast_sign_loss)] // bounded pixel/coord/colour/glyph cast

#[allow(clippy::similar_names)] // domain-standard coordinate/geometry/short-lived names

    // Column starts for the kept span: content-left reads from the right, etc.

    } else {

    };

        // Content up: src row = dst + px_dy (below) → iterate top→bottom.

    } else {

        // Content down: src row = dst - amt (above) → iterate bottom→top.

    }

/// Decide whether scroll frame `scroll_id` may use the [`scroll_shift_region`]

/// memmove fast path, or whether the caller must full-repaint the clip instead.

///

/// The memmove drags whatever is composited inside the clip. That is only WRONG

/// when transparent gaps in the SCROLLING content let static "backdrop" pixels

/// (painted *behind* the frame) show through and get dragged along. Per the

/// project's aggressive policy: take the fast path UNLESS that exact condition is

/// proven — i.e. fall back ONLY when (a) something is painted behind the frame

/// within the clip AND (b) the scrolling content does not opaquely cover the clip.

///

/// `scroll_offset` is the frame's current offset and `prev_offset` the offset

/// the pixels being moved were rendered at; both are used to project the

/// content's opaque fills (stored at content coords) into viewport space for

/// the coverage test — coverage must hold at BOTH offsets, since the memmove

/// drags pixels that were composited at the OLD offset. A scroll frame over

/// nothing-but-the-clear-color is always eligible (no backdrop to drag).

/// Returns `true` when there is no such frame (nothing to do).

#[allow(clippy::similar_names)] // domain-standard coordinate/geometry/short-lived names

#[allow(clippy::match_same_arms)] // enum/value mapping/dispatch table: one arm per input variant (or cross-type bindings that can't merge)

    // Locate the frame's content range [start+1, end).

    };

    // NESTED frame → ineligible. An inner frame's clip_bounds are the OUTER

    // frame's content coords: with the outer frame scrolled, the memmove

    // would shift a region displaced from the real on-screen clip by the

    // outer offset. Conservative full-clip repaint instead.

        }

    }

    // NOTE on overlays: anything painted AFTER the frame that overlaps the

    // clip (the frame's own scrollbar, an open dropdown, a tooltip) gets

    // dragged by the memmove. That does NOT make the frame ineligible — the

    // caller repaints those regions after the shift via

    // [`overlay_rects_after_frame`] (a scrollbar would otherwise disable the

    // fast path for every scroll container).

    // (a) Best case: the SCROLLING content opaquely covers the clip (projected

    // into viewport space by the scroll offset — at BOTH the old offset, where

    // the dragged pixels were rendered, and the new one). Then nothing behind

    // can ever show through, so the shift is always safe.

    // (b) Content has gaps. The drag is only VISIBLE if a NON-UNIFORM backdrop

    // shows through. Scan items behind the frame for SIGNIFICANT backdrop fills

    // (≥10% of the clip) — borders, text, shadows, thin/small decorations smear

    // imperceptibly and are ignored (aggressive policy: fall back only on a

    // proven artifact). Classify each significant backdrop item:

    //   - flat opaque Rect  → track its colour

    //   - Image / gradient  → non-uniform → not safe

    // Then: no significant backdrop → safe (only the clear behind); a single flat

    // colour that COVERS the clip → drags invisibly → safe; mixed colours, a

    // partial cover, or any non-uniform fill → full-repaint.

        };

        // Area of this item within the clip; ignore negligible coverage.

            {

                }

            }

            DisplayListItem::Image { .. }

            | DisplayListItem::LinearGradient { .. }

            | DisplayListItem::RadialGradient { .. }

        }

    }

    // Single flat colour: safe only if it fills the whole clip (else its edge

    // against the clear would drag visibly).

/// Result of diffing the GPU-animated values between two frames.

#[derive(Debug, Default)]

pub struct GpuValueDamage {

    /// Regions to repaint (scrollbar bounds whose thumb/opacity value changed).

    pub rects: Vec<LogicalRect>,

    /// A changed transform is bound to a `PushReferenceFrame` (drag / CSS

    /// transform animation): the moved CONTENT's extent isn't derivable from

    /// the item alone, so the caller must full-repaint.

    pub needs_full: bool,

}

/// Diff the GPU value maps of two frames and damage the items BOUND to the

/// changed keys.

///

/// Scrollbar thumb position, scrollbar fade opacity, and drag/CSS transforms

/// live in the GPU value cache; display-list items only carry the KEYS, so

/// they compare `is_visually_equal` while the pixels must change. Without

/// this channel, the `ScrollBarStyled` equality arm would freeze the thumb

/// (missed damage); with it, an idle window reaches `FrameDamage::None` even

/// with scrollbars present.

#[allow(clippy::implicit_hasher)] // internal call sites all use std hasher

    use std::collections::HashSet;

    }

    }

    }

    }

            }

            }

        }

    }

    // A changed key bound to nothing in THIS display list (another DOM's

    // scrollbar, a stale key) is ignored — it cannot affect these pixels.

/// Clip-intersected bounds of every item painted AFTER scroll frame

/// `scroll_id`'s `PopScrollFrame` that STRICTLY overlaps `clip_bounds`.

///

/// Anything composited over the frame inside its clip (the frame's own

/// scrollbar, an open dropdown/context menu/tooltip, a sibling's box-shadow)

/// gets DRAGGED by the `scroll_shift_region` memmove. Rather than making such

/// frames ineligible for the fast path (a scrollbar would disable it for

/// every scroll container), the caller adds these rects to the damage set so

/// the dragged pixels are simply repainted after the shift.

#[allow(clippy::similar_names)] // domain-standard coordinate/geometry/short-lived names