"""
CSS text utilities shared by the HTML analyzer.
Parses raw CSS into a selector→properties map and normalises values to pixels/hex.
"""
from __future__ import annotations

import colorsys
import re
from typing import Optional

_BASE_FONT_PX = 16.0  # browser default

# Full CSS4 named color table (148 entries)
_NAMED_COLORS: dict[str, str] = {
    "aliceblue": "#f0f8ff", "antiquewhite": "#faebd7", "aqua": "#00ffff",
    "aquamarine": "#7fffd4", "azure": "#f0ffff", "beige": "#f5f5dc",
    "bisque": "#ffe4c4", "black": "#000000", "blanchedalmond": "#ffebcd",
    "blue": "#0000ff", "blueviolet": "#8a2be2", "brown": "#a52a2a",
    "burlywood": "#deb887", "cadetblue": "#5f9ea0", "chartreuse": "#7fff00",
    "chocolate": "#d2691e", "coral": "#ff7f50", "cornflowerblue": "#6495ed",
    "cornsilk": "#fff8dc", "crimson": "#dc143c", "cyan": "#00ffff",
    "darkblue": "#00008b", "darkcyan": "#008b8b", "darkgoldenrod": "#b8860b",
    "darkgray": "#a9a9a9", "darkgreen": "#006400", "darkgrey": "#a9a9a9",
    "darkkhaki": "#bdb76b", "darkmagenta": "#8b008b", "darkolivegreen": "#556b2f",
    "darkorange": "#ff8c00", "darkorchid": "#9932cc", "darkred": "#8b0000",
    "darksalmon": "#e9967a", "darkseagreen": "#8fbc8f", "darkslateblue": "#483d8b",
    "darkslategray": "#2f4f4f", "darkslategrey": "#2f4f4f", "darkturquoise": "#00ced1",
    "darkviolet": "#9400d3", "deeppink": "#ff1493", "deepskyblue": "#00bfff",
    "dimgray": "#696969", "dimgrey": "#696969", "dodgerblue": "#1e90ff",
    "firebrick": "#b22222", "floralwhite": "#fffaf0", "forestgreen": "#228b22",
    "fuchsia": "#ff00ff", "gainsboro": "#dcdcdc", "ghostwhite": "#f8f8ff",
    "gold": "#ffd700", "goldenrod": "#daa520", "gray": "#808080",
    "green": "#008000", "greenyellow": "#adff2f", "grey": "#808080",
    "honeydew": "#f0fff0", "hotpink": "#ff69b4", "indianred": "#cd5c5c",
    "indigo": "#4b0082", "ivory": "#fffff0", "khaki": "#f0e68c",
    "lavender": "#e6e6fa", "lavenderblush": "#fff0f5", "lawngreen": "#7cfc00",
    "lemonchiffon": "#fffacd", "lightblue": "#add8e6", "lightcoral": "#f08080",
    "lightcyan": "#e0ffff", "lightgoldenrodyellow": "#fafad2", "lightgray": "#d3d3d3",
    "lightgreen": "#90ee90", "lightgrey": "#d3d3d3", "lightpink": "#ffb6c1",
    "lightsalmon": "#ffa07a", "lightseagreen": "#20b2aa", "lightskyblue": "#87cefa",
    "lightslategray": "#778899", "lightslategrey": "#778899", "lightsteelblue": "#b0c4de",
    "lightyellow": "#ffffe0", "lime": "#00ff00", "limegreen": "#32cd32",
    "linen": "#faf0e6", "magenta": "#ff00ff", "maroon": "#800000",
    "mediumaquamarine": "#66cdaa", "mediumblue": "#0000cd", "mediumorchid": "#ba55d3",
    "mediumpurple": "#9370db", "mediumseagreen": "#3cb371", "mediumslateblue": "#7b68ee",
    "mediumspringgreen": "#00fa9a", "mediumturquoise": "#48d1cc", "mediumvioletred": "#c71585",
    "midnightblue": "#191970", "mintcream": "#f5fffa", "mistyrose": "#ffe4e1",
    "moccasin": "#ffe4b5", "navajowhite": "#ffdead", "navy": "#000080",
    "oldlace": "#fdf5e6", "olive": "#808000", "olivedrab": "#6b8e23",
    "orange": "#ffa500", "orangered": "#ff4500", "orchid": "#da70d6",
    "palegoldenrod": "#eee8aa", "palegreen": "#98fb98", "paleturquoise": "#afeeee",
    "palevioletred": "#db7093", "papayawhip": "#ffefd5", "peachpuff": "#ffdab9",
    "peru": "#cd853f", "pink": "#ffc0cb", "plum": "#dda0dd",
    "powderblue": "#b0e0e6", "purple": "#800080", "rebeccapurple": "#663399",
    "red": "#ff0000", "rosybrown": "#bc8f8f", "royalblue": "#4169e1",
    "saddlebrown": "#8b4513", "salmon": "#fa8072", "sandybrown": "#f4a460",
    "seagreen": "#2e8b57", "seashell": "#fff5ee", "sienna": "#a0522d",
    "silver": "#c0c0c0", "skyblue": "#87ceeb", "slateblue": "#6a5acd",
    "slategray": "#708090", "slategrey": "#708090", "snow": "#fffafa",
    "springgreen": "#00ff7f", "steelblue": "#4682b4", "tan": "#d2b48c",
    "teal": "#008080", "thistle": "#d8bfd8", "tomato": "#ff6347",
    "transparent": "#ffffff", "turquoise": "#40e0d0", "violet": "#ee82ee",
    "wheat": "#f5deb3", "white": "#ffffff", "whitesmoke": "#f5f5f5",
    "yellow": "#ffff00", "yellowgreen": "#9acd32",
}

_GENERIC_FONT_KEYWORDS = frozenset({
    "serif", "sans-serif", "monospace", "cursive", "fantasy", "system-ui",
    "ui-serif", "ui-sans-serif", "ui-monospace",
})


def parse_css_rules(css_text: str) -> dict[str, dict[str, str]]:
    """
    Parse CSS text into {selector: {property: value}}.
    Handles comma-separated selectors. Skips @-rules.
    """
    # Strip comments
    css_text = re.sub(r"/\*.*?\*/", "", css_text, flags=re.DOTALL)
    # Strip @-rules (simplified — no nested support needed for our HTML samples)
    css_text = re.sub(r"@[^{]+\{[^{}]*\}", "", css_text, flags=re.DOTALL)

    rules: dict[str, dict[str, str]] = {}
    for match in re.finditer(r"([^{@]+)\{([^}]*)\}", css_text):
        raw_selectors = match.group(1).strip()
        declarations = match.group(2).strip()

        props: dict[str, str] = {}
        for decl in declarations.split(";"):
            decl = decl.strip()
            if ":" not in decl:
                continue
            prop, _, value = decl.partition(":")
            prop = prop.strip().lower()
            value = value.strip()
            if prop and value:
                props[prop] = value

        if not props:
            continue

        for selector in raw_selectors.split(","):
            selector = selector.strip()
            if selector:
                if selector in rules:
                    rules[selector].update(props)
                else:
                    rules[selector] = dict(props)

    return rules


def to_px(value: str, base_px: float = _BASE_FONT_PX) -> Optional[float]:
    """Convert a CSS length string to pixels. Returns None if not a valid length."""
    if not value:
        return None
    v = value.strip().lower()
    if v == "0":
        return 0.0
    if v in ("none", "auto", "inherit", "initial", "normal"):
        return None
    try:
        if v.endswith("px"):
            return float(v[:-2])
        if v.endswith("rem"):
            return float(v[:-3]) * base_px
        if v.endswith("em"):
            return float(v[:-2]) * base_px
        if v.endswith("pt"):
            return float(v[:-2]) * (4.0 / 3.0)
        if v.endswith("%"):
            return float(v[:-1]) * base_px / 100.0
    except ValueError:
        pass
    return None


def parse_shorthand_padding(padding: str) -> tuple[float, float, float, float]:
    """
    Parse a CSS padding/margin shorthand into (top, right, bottom, left) pixels.
    Returns (0,0,0,0) for empty or unparseable values.
    """
    parts = padding.split()
    values = [to_px(p) or 0.0 for p in parts if p]
    if len(values) == 1:
        v = values[0]
        return v, v, v, v
    if len(values) == 2:
        return values[0], values[1], values[0], values[1]
    if len(values) == 3:
        return values[0], values[1], values[2], values[1]
    if len(values) >= 4:
        return values[0], values[1], values[2], values[3]
    return 0.0, 0.0, 0.0, 0.0


def get_padding(styles: dict[str, str]) -> tuple[float, float, float, float]:
    """Resolve padding from a styles dict, letting individual sides override the shorthand."""
    top, right, bottom, left = parse_shorthand_padding(styles.get("padding", ""))
    t = to_px(styles.get("padding-top", ""))
    r = to_px(styles.get("padding-right", ""))
    b = to_px(styles.get("padding-bottom", ""))
    ll = to_px(styles.get("padding-left", ""))
    return (
        t if t is not None else top,
        r if r is not None else right,
        b if b is not None else bottom,
        ll if ll is not None else left,
    )


def normalize_color(color: str) -> Optional[str]:
    """Return a lowercase 6-digit hex colour string, or None if unparseable."""
    if not color:
        return None
    c = color.strip().lower()

    if c.startswith("#"):
        h = c[1:]
        if len(h) == 3:
            h = "".join(ch * 2 for ch in h)
        if len(h) == 6 and all(ch in "0123456789abcdef" for ch in h):
            return "#" + h

    # rgb() and rgba() — alpha channel ignored for contrast purposes
    m = re.match(r"rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)(?:\s*,\s*[\d.]+)?\s*\)", c)
    if m:
        r, g, b = (int(x) for x in m.groups()[:3])
        return f"#{r:02x}{g:02x}{b:02x}"

    # hsl() and hsla() — alpha ignored
    m = re.match(
        r"hsla?\(\s*([\d.]+)\s*,\s*([\d.]+)%\s*,\s*([\d.]+)%(?:\s*,\s*[\d.]+)?\s*\)", c
    )
    if m:
        h = float(m.group(1)) / 360.0
        s = float(m.group(2)) / 100.0
        ll = float(m.group(3)) / 100.0
        rf, gf, bf = colorsys.hls_to_rgb(h, ll, s)  # Python uses HLS order
        return f"#{round(rf * 255):02x}{round(gf * 255):02x}{round(bf * 255):02x}"

    return _NAMED_COLORS.get(c)


def parse_font_families(font_family: str) -> list[str]:
    """Extract named font families, skipping generic keywords."""
    families: list[str] = []
    for part in font_family.split(","):
        name = part.strip().strip('"').strip("'").strip()
        if name and name.lower() not in _GENERIC_FONT_KEYWORDS:
            families.append(name)
    return families


def parse_inline_style(style_attr: str) -> dict[str, str]:
    """Parse an HTML inline style attribute into a {property: value} dict."""
    result: dict[str, str] = {}
    for decl in style_attr.split(";"):
        if ":" in decl:
            prop, _, value = decl.partition(":")
            result[prop.strip().lower()] = value.strip()
    return result


def parse_media_breakpoints(css_text: str) -> list[int]:
    """Extract pixel widths from @media min-width/max-width queries."""
    widths: set[int] = set()
    for m in re.finditer(
        r"@media[^{]*(?:max-width|min-width)\s*:\s*(\d+)px", css_text, re.IGNORECASE
    ):
        widths.add(int(m.group(1)))
    return sorted(widths)


def has_hover_rules(css_text: str) -> bool:
    """Return True if any :hover pseudo-class rule exists in the CSS."""
    return bool(re.search(r":hover\s*\{", css_text))


def has_transition_rules(css_text: str) -> bool:
    """Return True if any CSS transition or @keyframes animation is defined."""
    return bool(re.search(r"\btransition\s*:|@keyframes\b|animation\s*:", css_text))


def has_focus_outline_removed(css_text: str) -> bool:
    """Return True if outline is set to none/0 without a replacement focus style."""
    stripped = re.sub(r"/\*.*?\*/", "", css_text, flags=re.DOTALL)
    return bool(re.search(r"outline\s*:\s*(?:none|0)\s*[;!}]", stripped))


def parse_font_faces(css_text: str) -> list[str]:
    """Return font-family names declared via @font-face blocks."""
    names: list[str] = []
    for m in re.finditer(r"@font-face\s*\{([^}]*)\}", css_text, re.DOTALL):
        fm = re.search(r"font-family\s*:\s*['\"]?([^;'\"]+)['\"]?\s*;", m.group(1))
        if fm:
            names.append(fm.group(1).strip().strip("'\""))
    return names


def has_font_display(css_text: str) -> bool:
    """Return True if at least one @font-face block declares font-display."""
    for m in re.finditer(r"@font-face\s*\{([^}]*)\}", css_text, re.DOTALL):
        if re.search(r"font-display\s*:", m.group(1)):
            return True
    return False