//! Headless backend for CPU-only rendering without a display server.

//!

//! This module provides the resource management and rendering pipeline for

//! running Azul applications without any platform windowing APIs. It works

//! in combination with `HeadlessWindow` (in `dll/src/desktop/shell2/headless/`) which

//! provides the `PlatformWindow` trait implementation.

//!

//! # Architecture

//!

//! The headless backend replaces the WebRender GPU pipeline with a purely

//! CPU-based approach. Here's how each resource type is managed:

//!

//! ```text

//! ┌──────────────────────────────────────────────────────────┐

//! │                    Normal (GPU) Path                     │

//! │                                                          │

//! │  LayoutWindow  ──→  DisplayList  ──→  WebRender  ──→  GL │

//! │       │                                    │              │

//! │       │              RenderApi   ←─── Renderer            │

//! │       │            (font/image              │              │

//! │       │             registration)     AsyncHitTester      │

//! │       │                                                   │

//! └──────────────────────────────────────────────────────────┘

//!

//! ┌──────────────────────────────────────────────────────────┐

//! │                  Headless (CPU) Path                      │

//! │                                                          │

//! │  LayoutWindow  ──→  DisplayList  ──→  cpurender  ──→  PNG│

//! │       │                                    │              │

//! │       │         HeadlessResources    (agg-rust           │

//! │       │         (font/image            Pixmap)            │

//! │       │          management)                              │

//! │       │                             CpuHitTester          │

//! │       │                                                   │

//! └──────────────────────────────────────────────────────────┘

//! ```

//!

//! ## Key Differences from GPU Path

//!

//! | Concern             | GPU Path                | Headless Path          |

//! |---------------------|-------------------------|------------------------|

//! | Window              | NSWindow / HWND / X11   | HeadlessWindow (no-op) |

//! | OpenGL              | GlContextPtr            | None                   |

//! | Renderer            | webrender::Renderer     | None (skip)            |

//! | RenderApi           | WrRenderApi             | None (skip)            |

//! | Hit Testing         | AsyncHitTester (WR)     | CpuHitTester (layout)  |

//! | Font Registration   | RenderApi::add_font()   | FontManager only       |

//! | Image Registration  | RenderApi::add_image()  | ImageCache only        |

//! | Frame Generation    | generate_frame() + WR   | generate_frame() only  |

//! | Screenshot          | glReadPixels            | cpurender → Pixmap     |

//! | Display List        | WR DisplayList          | solver3 DisplayList    |

//! | Present/Swap        | swapBuffers             | no-op                  |

//!

//! ## Resource Lifecycle (Headless)

//!

//! Fonts and images are managed entirely through `LayoutWindow`:

//!

//! ```text

//! Font Loading:

//!   1. FcFontCache discovers system fonts (same as GPU path)

//!   2. FontManager loads + caches parsed fonts

//!   3. TextLayoutCache shapes text and caches glyph positions

//!   4. cpurender reads glyph outlines directly from ParsedFont

//!      (no GPU texture atlas needed)

//!

//! Image Loading:

//!   1. ImageCache stores decoded images (same as GPU path)

//!   2. cpurender blits pixels directly from DecodedImage

//!      (no GPU texture upload needed)

//! ```

//!

//! ## Usage

//!

//! The headless backend is activated by setting `AZUL_HEADLESS=1`:

//!

//! ```bash

//! AZUL_HEADLESS=1 ./my_azul_app

//! ```

//!

//! Or combined with the debug server for remote inspection:

//!

//! ```bash

//! AZUL_HEADLESS=1 AZ_DEBUG=1 ./my_azul_app

//! ```

use std::collections::BTreeMap;

use azul_core::{

    dom::{DomId, NodeId},

    geom::{LogicalPosition, LogicalRect, LogicalSize},

    resources::RendererResources,

};

/// Configuration for headless rendering.

#[derive(Debug, Clone)]

pub struct HeadlessConfig {

    /// Logical window width in CSS pixels

    pub width: f32,

    /// Logical window height in CSS pixels

    pub height: f32,

    /// DPI scale factor (1.0 = 96 DPI, 2.0 = Retina)

    pub dpi_factor: f32,

    /// Whether to enable CPU rendering for screenshots

    /// (false = layout-only mode, no pixel output)

    pub enable_rendering: bool,

    /// Maximum number of event loop iterations before auto-close

    /// (prevents infinite loops in tests)

    pub max_iterations: Option<usize>,

}

/// Default safety limit for event loop iterations in headless/test mode.

const DEFAULT_MAX_ITERATIONS: usize = 1000;

impl Default for HeadlessConfig {

}

impl HeadlessConfig {

    /// Create with defaults. Viewport can be changed at runtime via

    /// the debug server's `resize` command or E2E test JSON steps.

}

/// CPU-based hit tester that works without WebRender.

///

/// In the GPU path, hit testing is done by `AsyncHitTester` which queries

/// WebRender's spatial tree. In headless mode, we do hit testing directly

/// against the layout results (positioned rectangles).

///

/// This is actually simpler and faster than the WebRender path, since we

/// don't need to go through the compositor's spatial tree — we just walk

/// the layout result nodes and check point-in-rect.

pub struct CpuHitTester {

    /// Cached hit test results from the last layout.

    /// Maps DomId -> list of (NodeId, positioned rect) sorted by paint order.

    node_rects: BTreeMap<DomId, Vec<HitTestEntry>>,

}

/// A single entry in the CPU hit test acceleration structure.

#[derive(Debug, Clone)]

struct HitTestEntry {

    /// The DOM node that this entry corresponds to.

    node_id: NodeId,

    /// Absolute position and size of this node in logical pixels.

    rect: LogicalRect,

    /// Clip rect (intersection of all ancestor overflow clips).

    clip: Option<LogicalRect>,

    /// Whether this node is pointer-events: none

    pointer_events_none: bool,

}

impl CpuHitTester {

    /// Create a new empty hit tester.

    /// Sum of HitTestEntry counts across all DomIds (for leak probes).

    /// Rebuild the hit test structure from layout results.

    ///

    /// Called after each layout pass. Extracts positioned rectangles from

    /// `LayoutWindow::layout_results` and builds a flat list for fast

    /// point-in-rect testing.

        // VirtualView / iframe child DOMs lay out in CHILD-LOCAL coordinates

        // (origin 0,0) but live on screen at the host VirtualView item's

        // bounds. Hit entries must be TRANSLATED there and CLIPPED to the

        // composite bounds — otherwise the child's nodes claim pointer events

        // across the whole window (live bug: azul-maps' tile grid ate every

        // click on the header toolbar, so the buttons never fired; the same

        // escape the renderer had before intersect_clips()).

        //

        // Resolve placements iteratively so nested VirtualViews accumulate

        // their host offsets (a child's own VirtualView item is in that

        // child's local space).

            // bounded depth; each pass resolves one nesting level

                } else {

                };

                    if let crate::solver3::display_list::DisplayListItem::VirtualView {

                        ..

                    {

                }

            }

        }

            // Child DOM: shift into window space + clip to the composite rect.

            };

            // Walk the layout nodes and their computed positions

                // Only include nodes that map to a real DOM node

                };

                // Get the position for this layout node

                };

                // Get the computed size

                };

            }

        }

    /// Perform a hit test at the given position.

    ///

    /// Returns nodes hit at (x, y) in reverse paint order (topmost first).

            // Walk in reverse (last painted = topmost)

                // Check clip rect first (if any)

                // Check node rect

            }

        }

}

/// Simple point-in-rect test.

/// Headless renderer for CPU-based screenshot capture.

///

/// Wraps `cpurender::render()` with headless-specific configuration.

/// This is separate from `CpuCompositor` (which implements the `Compositor`

/// trait for the WebRender software fallback path). The headless renderer

/// operates entirely without WebRender.

#[cfg(feature = "cpurender")]

pub struct HeadlessRenderer {

    pub width: f32,

    pub height: f32,

    pub dpi_factor: f32,

}

#[cfg(feature = "cpurender")]

impl HeadlessRenderer {

    /// Create a new headless renderer with the given dimensions.

    /// Render a display list to a pixel buffer.

    ///

    /// Returns an `AzulPixmap` that can be saved as PNG.

        )

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    #[test]

    #[test]

        // Inside

        // On edge

        // Outside

}