#[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::{DecodedImage, ImageRef, RendererResources};

use azul_core::ui_solver::GlyphInstance;

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

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

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

use azul_css::props::style::box_shadow::StyleBoxShadow;

use agg_rust::basics::{FillingRule, PATH_FLAGS_NONE};

use agg_rust::blur::stack_blur_rgba32;

use agg_rust::color::Rgba8;

use agg_rust::conv_stroke::ConvStroke;

use agg_rust::gradient_lut::GradientLut;

use agg_rust::path_storage::PathStorage;

use agg_rust::pixfmt_rgba::PixfmtRgba32;

use agg_rust::rasterizer_scanline_aa::RasterizerScanlineAa;

use agg_rust::renderer_base::RendererBase;

use agg_rust::renderer_scanline::render_scanlines_aa_solid;

use agg_rust::rendering_buffer::RowAccessor;

use agg_rust::rounded_rect::RoundedRect;

use agg_rust::scanline_u::ScanlineU8;

use agg_rust::span_gradient::{GradientConic, GradientRadialD, GradientX};

use agg_rust::trans_affine::TransAffine;

use crate::font::parsed::ParsedFont;

use crate::glyph_cache::GlyphCache;

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

use crate::text3::cache::{FontHash, FontManager};

const MAX_SHADOW_PIXBUF_SIZE: u32 = 4096;

/// Fallback color used when a `system:*` keyword cannot be resolved

/// (for example because no `SystemStyle` is attached to the

/// [`CpuRenderState`], or because the requested key is unset on the

/// current platform). CSS Images Level 4 leaves the color undefined in

/// this case; transparent black means the stop simply contributes

/// nothing to the gradient instead of poisoning it with an arbitrary

/// visible color (the previous behaviour was hardcoded mid-gray, which

/// produced visibly wrong output).

const SYSTEM_COLOR_FALLBACK: ColorU = ColorU {

    r: 0,

    g: 0,

    b: 0,

    a: 0,

};

/// Resolve a `ColorOrSystem` against the optional system palette.

///

/// Concrete colors are returned verbatim. `system:*` keywords are

/// resolved against `system_colors` when available and fall back to

/// `SYSTEM_COLOR_FALLBACK` otherwise.

#[allow(clippy::trivially_copy_pass_by_ref)] // <=8B Copy param kept by-ref intentionally (hot pixel/coord path or to avoid churning call sites for a perf-neutral change)

    }

/// Build a `GradientLut` from normalized linear color stops.

        // Need at least 2 stops; fill with transparent

/// Build a `GradientLut` from normalized radial (conic) color stops.

/// Resolve a background position to (`x_fraction`, `y_fraction`) in 0..1 range.

    use azul_css::props::style::background::{

        BackgroundPositionHorizontal, BackgroundPositionVertical,

    };

            } else {

            }

        }

    };

            } else {

            }

        }

    };

#[allow(clippy::cast_possible_truncation, clippy::cast_precision_loss)] // software rasterizer: bounded pixel/coord/colour casts

    use azul_css::props::basic::geometry::{LayoutRect, LayoutSize};

    };

    // Convert Direction to start/end points using the existing to_points method

    // Pixel-space start/end

    // gradient-space (0..100, 0) → pixel-space line (x1,y1)→(x2,y2). Use agg's

    // helper so the composition order is T * R * S — hand-rolling it via

    // new_translation().rotate().scale() pre-multiplies and ends up as

    // S * R * T, which rotates the translation and yields out-of-range gx.

    } else {

    };

    );

#[allow(clippy::suboptimal_flops)] // mul_add not guaranteed faster/available without target +fma; keep explicit a*b+c

#[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)

    use azul_css::props::style::background::{RadialGradientSize, Shape};

    };

    // Compute center from position

    // Compute radius based on shape and size

        RadialGradientSize::ClosestSide => {

            }

        }

        RadialGradientSize::FarthestSide => {

            }

        }

        RadialGradientSize::ClosestCorner => {

        }

        RadialGradientSize::FarthestCorner => {

        }

    };

    // Gradient-space (radius=100 at distance=100) → pixel-space around (cx, cy).

    // Build as T * S (scale first, then translate) so S only affects the radius.

    // scale() pre-multiplies so we must start from scaling matrix.

    } else {

    };

        0.0,

        100.0,

    );

#[allow(clippy::suboptimal_flops)] // mul_add not guaranteed faster/available without target +fma; keep explicit a*b+c

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

    };

    // Compute center

    // Start angle (CSS conic gradients start at 12 o'clock = -90deg in math coords)

    // Forward: gradient angle θ → pixel rotated by start_angle around (cx, cy).

    // Build as T * R so rotation is applied before translation (rotate() pre-multiplies,

    // so start from rotation matrix and translate last).

    // GradientConic maps atan2(y,x) * d / pi, covering [0, d] for the half-circle.

    // We use d2 = 100 as the range; the LUT maps 0..1 over that.

    } else {

    };

        0.0,

    );

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

// Box shadow rendering

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

#[allow(clippy::suboptimal_flops)] // mul_add not guaranteed faster/available without target +fma; keep explicit a*b+c

#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap, clippy::cast_sign_loss)] // software rasterizer: bounded pixel/coord/colour casts

    use azul_css::props::style::box_shadow::BoxShadowClipMode;

    };

    // Compute shadow rect (expanded by spread, padded by blur)

    // Create temp buffer and draw the shadow shape into it

    // The shape origin within the temp buffer

    };

    );

    // Apply blur

    // Blit the shadow buffer onto the main pixmap

/// Entry on the mask/opacity stack.

#[derive(Debug)]

pub enum MaskEntry {

    /// Image mask clip (R8 mask).

    ImageMask {

        snapshot: Vec<u8>,

        mask_data: Vec<u8>,

        origin_x: i32,

        origin_y: i32,

        width: u32,

        height: u32,

    },

    /// Opacity layer.

    Opacity {

        snapshot: Vec<u8>,

        rect: AzRect,

        opacity: f32,

    },

}

/// Extract and scale mask image data (R8) to target dimensions.

#[allow(clippy::cast_possible_truncation, clippy::cast_precision_loss, clippy::cast_sign_loss)] // software rasterizer: bounded pixel/coord/colour casts

            };

                azul_core::resources::RawImageFormat::BGRA8 => {

                    // Use alpha channel as mask

                }

                _ => {

                    // Use first channel as grayscale mask

                }

            }

        }

    };

    // Scale mask to target dimensions via nearest-neighbor

    }

/// Apply a mask: for each pixel in the mask region, blend between the snapshot

/// (pre-mask state) and the current pixmap state using the mask value.

#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap, clippy::cast_sign_loss)] // software rasterizer: bounded pixel/coord/colour casts

        MaskEntry::ImageMask {

    };

            // Blend: result = snapshot * (255 - mask) + current * mask

            // mask_val 255 = fully visible (keep current), 0 = fully clipped (restore snapshot)

        }

    }

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

// Public API

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

#[derive(Debug, Clone, Copy)]

pub struct RenderOptions {

    pub width: f32,

    pub height: f32,

    pub dpi_factor: f32,

}

/// Reuse `retained` pixmap if it matches the target dimensions, otherwise allocate new.

#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] // software rasterizer: bounded pixel/coord/colour casts

/// # Errors

///

/// Returns an error string if rendering fails.

    let RenderOptions {

/// Render a display list using fonts from `FontManager` directly.

/// This is used in reftest scenarios where `RendererResources` doesn't have fonts registered.

/// # Errors

///

/// Returns an error string if rendering fails.

/// Render with `FontManager` and explicit render state (scroll offsets + GPU values).

/// Used by `take_screenshot` to render with the current scroll/transform/opacity state.

/// # Errors

///

/// Returns an error string if rendering fails.

    )

/// Render with optional retained pixmap. If `retained` is Some and matches

/// the target dimensions, it is reused (cleared to white) instead of

/// allocating a fresh buffer. The pixmap is returned regardless.

#[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)] // software rasterizer: bounded pixel/coord/colour casts

/// # Errors

///

/// Returns an error string if rendering fails.

    let RenderOptions {

/// Scroll offsets keyed by `scroll_id` (`LocalScrollId`).

/// Passed to the renderer so it can look up the current scroll position

/// for each `PushScrollFrame` without embedding it in the display list.

pub type ScrollOffsetMap = HashMap<LocalScrollId, (f32, f32)>;

/// Consolidated render-time state for CPU rendering.

///

/// Bundles scroll offsets and GPU-animated values (transforms, opacities)

/// that `WebRender` would normally manage internally. In cpurender these

/// are looked up from the `GpuValueCache` at screenshot time.

#[derive(Debug)]

pub struct CpuRenderState {

    /// Scroll offsets by `scroll_id`

    pub scroll_offsets: ScrollOffsetMap,

    /// Transform values keyed by TransformKey.id — scrollbar thumb positions

    /// and CSS transforms that are GPU-animated in `WebRender`.

    pub transforms: HashMap<usize, azul_core::transform::ComputedTransform3D>,

    /// Opacity values keyed by OpacityKey.id — scrollbar fade-in/out.

    /// For `WhenScrolling` mode, opacity is 1.0 when recently scrolled,

    /// fades to 0.0 after idle. For Always mode, opacity is always 1.0.

    pub opacities: HashMap<usize, f32>,

    /// System style for resolving system color references inside gradient

    /// stops (e.g. `system:accent` in macOS button backgrounds). When None,

    /// system color stops fall back to a transparent color.

    pub system_style: Option<std::sync::Arc<azul_css::system::SystemStyle>>,

    /// Display lists of nested `VirtualView` child DOMs, keyed by their

    /// `child_dom_id`. The `WebRender` path composites these via separate pipelines;

    /// the CPU path has no pipelines, so the `DisplayListItem::VirtualView` arm

    /// recursively rasterises the child's display list from here (translated to the

    /// item's `bounds.origin`, clipped to `bounds`). Empty for non-window renders.

    pub virtual_view_display_lists:

        std::collections::BTreeMap<azul_core::dom::DomId, std::sync::Arc<DisplayList>>,

    /// Resolved images for `DecodedImage::Callback` `<img>` nodes, keyed by the

    /// callback image's hash. The CPU renderer can't invoke `RenderImageCallback`s

    /// itself (it would draw a grey placeholder); the backend pre-invokes them

    /// via [`crate::window::LayoutWindow::invoke_cpu_image_callbacks`] and passes

    /// the produced images here, where the `DisplayListItem::Image` arm looks

    /// them up by hash. Empty when there are no callback images.

    pub image_callback_results:

        std::collections::BTreeMap<azul_core::resources::ImageRefHash, ImageRef>,

}

impl CpuRenderState {

    /// Provide the resolved `RenderImageCallback` images (see the field doc).

    /// Provide the nested `VirtualView` child DOM display lists so the CPU

    /// renderer can composite them (see the field doc).

    /// Attach a `SystemStyle` so the renderer can resolve `system:*` color

    /// keywords (e.g. in gradient stops) against the live OS palette.

    /// Build from a `GpuValueCache` snapshot.

}

/// Flatten the GPU value cache into `key.id → value` maps — the SAME

/// extraction `CpuRenderState::from_gpu_cache` feeds the renderer with.

///

/// Exposed separately so the damage layer can diff the values frame-to-frame:

/// scrollbar thumb position / fade opacity / drag & CSS transforms change

/// WITHOUT any display-list item changing (items only carry the keys), so a

/// pure item diff reports "visually equal" while the frame must repaint.

    {

            // Scrollbar thumb transforms (vertical)

            }

            // Scrollbar thumb transforms (horizontal)

            }

            // CSS transforms

            }

            // Scrollbar opacity (vertical)

            }

            // Scrollbar opacity (horizontal)

            }

            // CSS opacity

            }

    }

    )

    // Accumulated scroll offset stack. Each PushScrollFrame pushes

    // (parent_offset_x + scroll_x, parent_offset_y + scroll_y).

    // Items inside a scroll frame have their bounds shifted by the

    // accumulated offset before rendering.

    }

/// Compact item-kind label for [`crate::probe`]. Names must be `'static`

/// strings (probe events store `&'static str` for cheap aggregation),

/// hence the closed match instead of formatting `Debug`.

#[inline]

    use crate::solver3::display_list::DisplayListItem as I;

    }

/// Render only the damaged regions of a display list into a retained pixmap.

///

/// For each damage rect:

/// 1. Clear that region in the pixmap (fill with background color).

/// 2. Iterate all display list items, skip those entirely outside the damage rect.

/// 3. Render intersecting items clipped to the damage rect.

///

/// Push/Pop state commands are always processed (they maintain clip/scroll stacks).

#[allow(clippy::cast_possible_truncation)] // software rasterizer: bounded pixel/coord/colour casts

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

#[allow(clippy::cast_possible_wrap, clippy::cast_precision_loss)] // bounded layout/render numeric cast

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

/// # Panics

///

/// Panics if the damage-rect iterator is unexpectedly empty.

/// # Errors

///

/// Returns an error string if rendering fails.

    // A damage rect snapped OUTWARD to physical-pixel boundaries, carried

    // BOTH as physical ints (clear + clip) and as the equivalent logical

    // rect (item filter).

    struct SnappedRect {

        x0: i32,

        y0: i32,

        x1: i32,

        y1: i32,

        logical: LogicalRect,

    }

    // Snap every damage rect OUTWARD to physical-pixel boundaries (floor the

    // origin, ceil the far edge). Truncating instead leaves a fractional

    // right/bottom sliver that is neither cleared nor repainted — a 1-2px

    // stale ghost line whenever bounds are fractional (text heights like

    // 18.625, any dpi ≠ 1). The snapped rect is carried BOTH as physical ints

    // (clear + clip) and as the equivalent logical rect (item filter), so the

    // filter admits every item that touches a cleared pixel.

    // Merge OVERLAPPING rects (strictly overlapping in physical pixels; rects

    // that merely touch stay separate). After this, the rects are pairwise

    // disjoint, so the per-rect passes below clear + paint every damaged pixel

    // EXACTLY once — no double alpha-blend where rects used to overlap, and no

    // ballooned union.

        }

            // re-scan the same i (the union may reach earlier-skipped rects)

    }

    // One pass PER damage rect, each with its own clip seeded to exactly that

    // rect. An item spanning several rects renders once per rect, but the

    // rects are disjoint so no pixel is ever blended twice. Crucially, an item

    // that intersects rect A but not rect B repaints ONLY inside A — the old

    // union-clip approach let such an item paint across the whole union,

    // overwriting neighbours between the rects that were themselves filtered

    // out (skipped), which ERASED untouched content lying between two disjoint

    // damage rects (e.g. window background + scroll strip + scrollbar column:

    // the background repainted the entire union = whole window, while all the

    // rows in the middle were skipped → visually wiped).

            255,

            255,

            255,

            255,

        );

        );

            // Always process state-management items (Push/Pop) regardless of bounds,

            // because skipping a Push while processing its matching Pop corrupts stacks.

                    // Items inside a scroll frame are stored at CONTENT coords but

                    // RENDER at `pos - scroll_offset`. The damage rects are in viewport

                    // space, so we must apply the current scroll offset to the bounds

                    // before the intersection test — otherwise scrolled content is

                    // filtered against the wrong position and rows that actually fall

                    // in a damage strip get dropped (visible as a missing band).

                    } else {

                    };

        }

    }

#[allow(clippy::cast_possible_truncation, clippy::cast_possible_wrap, clippy::cast_sign_loss)] // software rasterizer: bounded pixel/coord/colour casts

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

#[allow(clippy::float_cmp)] // intentional exact compare: change-detection / identity fast-path / cache-key match

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

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

/// # Panics

///

/// Panics if the clip stack is empty when an item expects an active clip.

/// # Errors

///

/// Returns an error string if rendering fails.

    use azul_css::props::style::border::BorderStyle;

    // Current accumulated scroll offset — applied to all item bounds.

    // Negative because scrolling down (positive offset) moves content up.

    // Helper: apply scroll offset to a LogicalRect.

    // Items inside scroll frames have absolute window coordinates;

    // the scroll offset shifts them so the visible portion aligns

    // with the clip region.

        DisplayListItem::Rect {

        DisplayListItem::SelectionRect {

        DisplayListItem::Border {