//! Post-layout developer warnings for misused raw text nodes.

//!

//! Browsers wrap a raw text run in an ANONYMOUS BLOCK whenever it needs one;

//! azul does not. A bare `NodeType::Text` therefore has no box of its own —

//! no rect, no clip, no layout constraints — and every box-model CSS

//! property, every id or class a stylesheet could reach it by, and every

//! callback, `tab_index` or `dataset` attached to one is silently inert.

//! That silence has shipped real bugs (text escaping its widget, click

//! targets that never fire), which is why the raw constructor is named

//! `create_p_with_text` and why this pass

//! exists: after layout, every text node in a shape azul cannot honor is

//! reported to the developer, once per unique finding.

//!

//! The checks are structural (DOM + computed display), deliberately not

//! geometric: they fire deterministically on the first layout of a DOM,

//! before any symptom is visible on screen.

//!

//! This runs after EVERY layout pass, in release, so it is built to cost

//! nothing on a clean DOM: the scan allocates only once a finding exists,

//! message text (two allocations for the snippet alone) is rendered only for

//! a warning that is actually printed, and the per-parent questions ("is

//! there a block-level child?", "how many items?") are answered once per

//! parent instead of once per text child.

use std::collections::BTreeSet;

use std::hash::{Hash, Hasher};

use std::mem::discriminant;

use std::sync::Mutex;

use azul_core::{

    dom::{AttributeType, NodeType},

    id::NodeId,

    styled_dom::{NodeHierarchyItem, StyledDom},

};

use azul_css::props::layout::LayoutDisplay;

use crate::solver3::getters::{get_display_property, MultiValue};

/// Distinct findings kept alive process-wide. A DOM that is wrong in a

/// hundred places has one bug, not a hundred; past this the developer is

/// told the tap was closed rather than having the log drowned.

const MAX_DISTINCT_WARNINGS: usize = 32;

/// Findings already reported, keyed by [`dedup_key`], process-wide. Layouts

/// re-run constantly (every DOM refresh); a warning that repeats 60 times a

/// second is a warning nobody reads.

struct Emitted {

    keys: BTreeSet<u64>,

    capped: bool,

}

static EMITTED: Mutex<Emitted> = Mutex::new(Emitted {

    keys: BTreeSet::new(),

    capped: false,

});

/// The suppression tag for this lint, honored from the `AZ_SUPPRESS`

/// environment variable (comma-separated list; the common misspelling

/// `AZ_SUPRESS` is accepted too). Every emitted warning names it.

pub const SUPPRESS_TAG: &str = "bare_text";

/// `AZ_SUPPRESS=bare_text` (checked once): the developer has read the

/// warnings and wants them off — e.g. a codebase that deliberately renders

/// raw text and accepts the differences from browser behavior.

    static SUPPRESSED: std::sync::OnceLock<bool> = std::sync::OnceLock::new();

/// State on a text node that a text node cannot carry, as a bitset so the

/// scan can record a finding without allocating.

const INERT_CSS: u8 = 1 << 0;

const INERT_IDS_CLASSES: u8 = 1 << 1;

const INERT_CALLBACKS: u8 = 1 << 2;

const INERT_TAB_INDEX: u8 = 1 << 3;

const INERT_DATASET: u8 = 1 << 4;

const INERT_CHILDREN: u8 = 1 << 5;

/// One finding, kept as a tag until a message is known to be needed.

#[derive(Clone, Copy)]

enum Finding {

    /// W1 — box-less node carrying state (bitset of the `INERT_*` flags).

    Inert(u8),

    /// W2 — the text run is the root: nothing owns its box.

    NoParent,

    /// W2 — text nested directly inside text.

    TextParent,

    /// W2 — one of several items in a flex/grid container.

    FlexItem {

        display: LayoutDisplay,

        child_count: usize,

    },

    /// W2 — mixed inline/block content: no line box of its own.

    BlockSibling,

}

impl Finding {

    /// Orders findings on the same node the way the checks are written

    /// (state first, placement second) — the scan visits a text node and its

    /// parent in different iterations, so the sort needs the tie-break.

        }

}

    }

        LayoutDisplay::Flex

            | LayoutDisplay::InlineFlex

            | LayoutDisplay::Grid

            | LayoutDisplay::InlineGrid

    )

        LayoutDisplay::Inline

            | LayoutDisplay::InlineBlock

            | LayoutDisplay::InlineFlex

            | LayoutDisplay::InlineGrid

            | LayoutDisplay::InlineTable

            | LayoutDisplay::None

    )

/// Walk `styled_dom` and tag every text node used in a shape azul cannot

/// honor. Allocation-free while nothing is wrong.

        };

            // W1 — state on a box-less node: every one of these is inert on

            // a text node, because only the wrapping block box carries a

            // rect. An id or a class counts: it is how a stylesheet reaches

            // the node, and every rule it selects computes onto a node that

            // never gets one.

            // W2 — no containing block the text can live in. Browsers would

            // generate an anonymous block here; azul does not. The remaining

            // W2 shapes depend only on the PARENT, so they are decided once

            // in the parent's own iteration below.

            }

        // Parent-major placement checks. Answering "does this parent have a

        // block-level child / how many items does it have?" once per parent

        // keeps the pass linear; asking it per text child made a wide parent

        // with several text children quadratic.

            // The overwhelmingly common case: no display lookup, no second

            // sweep, nothing allocated.

            // A text leaf as the SOLE child of a flex/grid box is the

            // sanctioned wrapper pattern (the parent is the box that carries

            // the styling — badge, the converted labels). The hazard is text

            // as ONE OF SEVERAL items: it competes in item layout with no box

            // of its own.

        } else {

            // Mixed inline + block content under one parent: the text has no

            // dedicated line box of its own next to block siblings.

                {

            }

        };

        }

    }

    // Node order, so a finding reads in the order the DOM was written.

/// Walk `styled_dom` and return one message per text node that is used in a

/// shape azul cannot honor. Pure — the caller decides how to report.

#[must_use]

/// Build the developer-facing text. Only called for a finding that is about

/// to be printed — the snippet alone costs two allocations.

    };

            )

        }

        ),

        ),

        Finding::FlexItem {

        ),

        ),

    }

/// Identify the PROBLEM, not the node.

///

/// Node indices shift on every structural edit — i.e. on every keystroke in

/// a live document — so an index-derived key re-hashes each frame: the same

/// finding re-prints forever AND the dedup set grows without bound. The kind

/// of finding plus the styling identity of the text node and its parent is

/// stable across edits, and it is what the developer actually fixes: one

/// construction site.

        // NOT the child_count: adding an item to the container is not a new

        // bug.

    }

    }

/// The part of a node that survives a DOM rebuild: what it is and how it is

/// selected. Deliberately not its text, which may be per-frame data.

        }

    }

/// Report every finding from [`collect_text_placement_warnings`] to stderr,

/// once per unique finding per process. Call after layout.

    };

            );

        );

    }

#[cfg(test)]

mod autotest_generated {

    use azul_core::dom::{Dom, IdOrClass, IdOrClassVec, TabIndex};

    use azul_core::styled_dom::StyledDom;

    use azul_css::css::Css;

    use super::collect_text_placement_warnings;

    fn styled(mut dom: Dom, css: &str) -> StyledDom {

        let css = if css.is_empty() {

            Css::empty()

        } else {

            Css::from_string(css.into())

        };

        StyledDom::create(&mut dom, css)

    }

    fn raw_text(s: &str) -> Dom {

        Dom::create_text_do_not_use_without_block_level_wrapper(s)

    }

    #[test]

    fn a_correctly_wrapped_text_produces_no_warning() {

        let sd = styled(

            Dom::create_body().with_child(Dom::create_p_with_text("hello")),

            "",

        );

        assert_eq!(collect_text_placement_warnings(&sd), Vec::<String>::new());

    }

    #[test]

    fn text_inside_an_inline_span_inside_a_block_is_fine() {

        let sd = styled(

            Dom::create_body()

                .with_child(Dom::create_p().with_child(Dom::create_span_with_text("hi"))),

            "",

        );

        assert_eq!(collect_text_placement_warnings(&sd), Vec::<String>::new());

    }

    #[test]

    fn state_on_a_text_node_is_reported_as_inert() {

        let text = raw_text("styled").with_tab_index(TabIndex::Auto);

        let sd = styled(Dom::create_body().with_child(Dom::create_p().with_child(text)), "");

        let w = collect_text_placement_warnings(&sd);

        assert_eq!(w.len(), 1, "{w:?}");

        assert!(w[0].contains("INERT"), "{w:?}");

        assert!(w[0].contains("tab_index"), "{w:?}");

    }

    #[test]

    fn ids_and_classes_on_a_text_node_are_reported_as_inert() {

        // The shipped menu_renderer defect: the checkmark's three classes

        // ended up on the text node instead of the icon <div> that boxes it.

        // The text is that div's only child — the shape every placement check

        // calls sanctioned — so the classes are the only thing left to report.

        let icon = raw_text("✓").with_ids_and_classes(IdOrClassVec::from_vec(vec![

            IdOrClass::Class("menu-item-icon".into()),

            IdOrClass::Class("menu-item-checkbox".into()),

            IdOrClass::Class("menu-item-checkbox-checked".into()),

        ]));

        let sd = styled(

            Dom::create_body().with_child(Dom::create_div().with_child(icon)),

            "",

        );

        let w = collect_text_placement_warnings(&sd);

        assert_eq!(w.len(), 1, "{w:?}");

        assert!(w[0].contains("INERT"), "{w:?}");

        assert!(w[0].contains("ids/classes"), "{w:?}");

    }

    #[test]

    fn a_sole_text_leaf_in_a_flex_wrapper_is_the_sanctioned_pattern() {

        // badge / the converted labels: the flex box IS the wrapper.

        let sd = styled(

            Dom::create_body().with_child(Dom::create_div().with_child(raw_text("flexed"))),

            "div { display: flex; }",

        );

        assert_eq!(collect_text_placement_warnings(&sd), Vec::<String>::new());

    }

    #[test]

    fn text_competing_with_other_flex_items_is_reported() {

        // The tree_view/radio_group shape: a raw label beside element items.

        let sd = styled(

            Dom::create_body().with_child(

                Dom::create_div()

                    .with_child(Dom::create_div())

                    .with_child(raw_text("flexed")),

            ),

            "body > div { display: flex; }",

        );

        let w = collect_text_placement_warnings(&sd);

        assert_eq!(w.len(), 1, "{w:?}");

        assert!(w[0].contains("competes in flex/grid"), "{w:?}");

    }

    #[test]

    fn text_next_to_a_block_sibling_is_reported() {

        // The audited frame.rs shape: a title wedged between two divs.

        let sd = styled(

            Dom::create_body().with_child(

                Dom::create_div()

                    .with_child(Dom::create_div())

                    .with_child(raw_text("title"))

                    .with_child(Dom::create_div()),

            ),

            "",

        );

        let w = collect_text_placement_warnings(&sd);

        assert_eq!(w.len(), 1, "{w:?}");

        assert!(w[0].contains("block-level siblings"), "{w:?}");

    }

    #[test]

    fn several_text_children_of_one_parent_are_all_reported() {

        // The per-parent memo must not swallow the sibling text runs it was

        // computed for.

        let sd = styled(

            Dom::create_body().with_child(

                Dom::create_div()

                    .with_child(raw_text("a"))

                    .with_child(Dom::create_div())

                    .with_child(raw_text("b")),

            ),

            "",

        );

        let w = collect_text_placement_warnings(&sd);

        assert_eq!(w.len(), 2, "{w:?}");

        assert!(w[0].contains("\"a\""), "{w:?}");

        assert!(w[1].contains("\"b\""), "{w:?}");

    }

    #[test]

    fn findings_are_reported_in_node_order() {

        // The two text runs are found via DIFFERENT parents (one nested, one

        // directly under body), so the scan reaches them out of order and the

        // sort has to put them back.

        let sd = styled(

            Dom::create_body()

                .with_child(

                    Dom::create_div()

                        .with_child(Dom::create_div())

                        .with_child(raw_text("deep")),

                )

                .with_child(raw_text("shallow"))

                .with_child(Dom::create_div()),

            "",

        );

        let w = collect_text_placement_warnings(&sd);

        assert_eq!(w.len(), 2, "{w:?}");

        let indices: Vec<usize> = w

            .iter()

            .map(|m| {

                m.split_whitespace()

                    .nth(2)

                    .and_then(|n| n.parse().ok())

                    .unwrap_or_else(|| panic!("no node index in {m:?}"))

            })

            .collect();

        assert!(indices[0] < indices[1], "{indices:?} / {w:?}");

    }

    #[test]

    fn every_widget_dom_is_warning_free() {

        // The runtime twin of the widgets' label-convention test: none of the

        // shipped widgets may trip the developer warning.

        for (name, dom) in crate::widgets::all_widget_doms_for_lint() {

            let sd = styled(Dom::create_body().with_child(dom), "");

            let w = collect_text_placement_warnings(&sd);

            assert_eq!(w, Vec::<String>::new(), "widget {name} trips the text lint: {w:?}");

        }

    }

}