"""
Per-Element HTML Structure Analysis (Cross-Method Comparison)
==============================================================
Analyzes generated HTML across all methods without requiring ground truth.
Uses the best-performing method (qwen3_1k) as reference baseline.

Metrics per method:
  - DOM depth, node count, element type distribution
  - CSS property count & diversity
  - Text content F1 vs reference method
  - Element recall/precision vs reference method
  - Output token efficiency (quality per token)

Usage:
    python scripts/step_element_analysis.py
"""

import json
import re
import sys
from collections import Counter, defaultdict
from pathlib import Path

PROJECT_ROOT = Path(__file__).parent.parent
sys.path.insert(0, str(PROJECT_ROOT))

from bs4 import BeautifulSoup


TAG_GROUPS = {
    "buttons": {"button"},
    "inputs": {"input", "textarea", "select"},
    "images": {"img", "svg", "picture"},
    "links": {"a"},
    "headings": {"h1", "h2", "h3", "h4", "h5", "h6"},
    "lists": {"ul", "ol", "li"},
    "tables": {"table", "tr", "td", "th"},
    "forms": {"form"},
    "nav": {"nav", "header", "footer", "aside"},
    "containers": {"div", "section", "article", "main"},
    "text_inline": {"p", "span", "label", "strong", "em", "b", "i"},
}


def extract_elements(html_str):
    try:
        soup = BeautifulSoup(html_str, "html.parser")
    except Exception:
        return {}
    counts = {}
    for category, tags in TAG_GROUPS.items():
        counts[category] = sum(len(soup.find_all(tag)) for tag in tags)
    counts["total_tags"] = len(soup.find_all(True))
    return counts


def extract_css_props(html_str):
    props = Counter()
    for match in re.finditer(r'style\s*=\s*"([^"]*)"', html_str, re.IGNORECASE):
        for prop in match.group(1).split(";"):
            if ":" in prop:
                name = prop.split(":")[0].strip().lower()
                if name:
                    props[name] += 1
    for match in re.finditer(r'<style[^>]*>(.*?)</style>', html_str, re.DOTALL | re.IGNORECASE):
        for prop in re.findall(r'([\w-]+)\s*:', match.group(1)):
            props[prop.lower()] += 1
    return dict(props)


def extract_text(html_str):
    try:
        soup = BeautifulSoup(html_str, "html.parser")
        for tag in soup(["script", "style", "meta", "link"]):
            tag.decompose()
        return soup.get_text(separator=" ", strip=True)
    except Exception:
        return ""


def dom_metrics(html_str):
    try:
        soup = BeautifulSoup(html_str, "html.parser")
    except Exception:
        return {"max_depth": 0, "total_nodes": 0}

    max_depth = 0
    stack = [(soup, 0)]
    while stack:
        el, d = stack.pop()
        if d > max_depth:
            max_depth = d
        if d > 200:
            continue
        for c in el.children:
            if hasattr(c, 'name') and c.name:
                stack.append((c, d + 1))

    return {
        "max_depth": max_depth,
        "total_nodes": len(soup.find_all(True)),
    }


def char_f1(pred, ref):
    if not pred and not ref:
        return 1.0
    if not pred or not ref:
        return 0.0
    pc, rc = Counter(pred.lower()), Counter(ref.lower())
    common = sum((pc & rc).values())
    if common == 0:
        return 0.0
    p = common / sum(pc.values())
    r = common / sum(rc.values())
    return 2 * p * r / (p + r)


def element_f1(pred_counts, ref_counts):
    results = {}
    for cat in TAG_GROUPS:
        rn = ref_counts.get(cat, 0)
        pn = pred_counts.get(cat, 0)
        if rn == 0 and pn == 0:
            results[cat] = 1.0
        elif rn == 0 or pn == 0:
            results[cat] = 0.0
        else:
            matched = min(pn, rn)
            recall = matched / rn
            precision = matched / pn
            results[cat] = 2 * recall * precision / (recall + precision)
    return results


def analyze_all(benchmark_dir, ref_method="qwen3_1k"):
    bench = Path(benchmark_dir)
    methods = sorted(d.name for d in bench.iterdir()
                     if d.is_dir() and (d / "html_predictions").exists())

    if ref_method not in methods:
        print(f"Reference method {ref_method} not found, using first: {methods[0]}")
        ref_method = methods[0]

    ref_dir = bench / ref_method / "html_predictions"
    ref_htmls = {}
    for f in sorted(ref_dir.glob("*.html")):
        ref_htmls[f.stem] = f.read_text(encoding="utf-8", errors="ignore")

    print(f"Reference: {ref_method} ({len(ref_htmls)} samples)")

    ref_elements = {sid: extract_elements(h) for sid, h in ref_htmls.items()}
    ref_texts = {sid: extract_text(h) for sid, h in ref_htmls.items()}
    ref_css = {sid: extract_css_props(h) for sid, h in ref_htmls.items()}

    all_results = {}

    for method in methods:
        html_dir = bench / method / "html_predictions"
        pred_htmls = {}
        for f in sorted(html_dir.glob("*.html")):
            if f.stem in ref_htmls:
                pred_htmls[f.stem] = f.read_text(encoding="utf-8", errors="ignore")

        if not pred_htmls:
            continue

        text_f1s = []
        dom_depths = []
        dom_nodes = []
        css_counts = []
        css_unique = []
        elem_f1s = defaultdict(list)
        total_element_f1s = []

        for sid, pred_html in pred_htmls.items():
            pred_elem = extract_elements(pred_html)
            ref_elem = ref_elements.get(sid, {})
            pred_text = extract_text(pred_html)
            ref_text = ref_texts.get(sid, "")
            pred_css = extract_css_props(pred_html)
            dm = dom_metrics(pred_html)

            text_f1s.append(char_f1(pred_text, ref_text))
            dom_depths.append(dm["max_depth"])
            dom_nodes.append(dm["total_nodes"])
            css_counts.append(sum(pred_css.values()))
            css_unique.append(len(pred_css))

            ef1 = element_f1(pred_elem, ref_elem)
            for cat, val in ef1.items():
                elem_f1s[cat].append(val)
            total_element_f1s.append(sum(ef1.values()) / len(ef1))

        n = len(pred_htmls)
        per_cat = {}
        for cat in TAG_GROUPS:
            vals = elem_f1s[cat]
            per_cat[cat] = round(sum(vals) / len(vals), 4) if vals else 0

        result = {
            "n_samples": n,
            "avg_text_f1": round(sum(text_f1s) / n, 4),
            "avg_element_f1": round(sum(total_element_f1s) / n, 4),
            "avg_dom_depth": round(sum(dom_depths) / n, 1),
            "avg_dom_nodes": round(sum(dom_nodes) / n, 1),
            "avg_css_properties": round(sum(css_counts) / n, 1),
            "avg_css_unique_props": round(sum(css_unique) / n, 1),
            "per_category_f1": per_cat,
        }
        all_results[method] = result

    return all_results


def main():
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument("--benchmark_dir", default=str(PROJECT_ROOT / "results" / "benchmark"))
    parser.add_argument("--ref_method", default="qwen3_1k")
    parser.add_argument("--output", default=str(PROJECT_ROOT / "results" / "element_analysis.json"))
    args = parser.parse_args()

    results = analyze_all(args.benchmark_dir, args.ref_method)

    Path(args.output).parent.mkdir(parents=True, exist_ok=True)
    with open(args.output, "w") as f:
        json.dump(results, f, indent=2)

    print(f"\n{'='*90}")
    print(f"{'Method':<25} {'TextF1':>8} {'ElemF1':>8} {'Depth':>6} {'Nodes':>7} {'CSS':>6} {'N':>4}")
    print("-" * 70)
    for k in sorted(results, key=lambda x: results[x]["avg_text_f1"], reverse=True):
        v = results[k]
        print(f"{k:<25} {v['avg_text_f1']:>8.4f} {v['avg_element_f1']:>8.4f} "
              f"{v['avg_dom_depth']:>6.1f} {v['avg_dom_nodes']:>7.0f} "
              f"{v['avg_css_properties']:>6.0f} {v['n_samples']:>4}")
    print(f"{'='*90}")

    print("\nPer-category Element F1 (vs qwen3_1k):")
    cats = list(TAG_GROUPS.keys())
    header = f"{'Method':<25}" + "".join(f"{c[:6]:>8}" for c in cats)
    print(header)
    print("-" * (25 + 8 * len(cats)))
    for method in sorted(results):
        row = f"{method:<25}"
        for cat in cats:
            val = results[method]["per_category_f1"].get(cat, 0)
            row += f"{val:>8.3f}"
        print(row)

    print(f"\nSaved to: {args.output}")


if __name__ == "__main__":
    main()