Popup Cro

#!/usr/bin/env python3
"""Popup A/B Test Calculator - Calculate statistical significance for popup experiments.

Takes impressions and conversions for control and variant, computes conversion rates,
relative lift, Z-score, p-value, and confidence level. Recommends ship, continue, or abandon.

Usage:
    python popup_ab_test_calculator.py test.json
    python popup_ab_test_calculator.py test.json --format json
"""

import argparse
import json
import math
import sys
from typing import Any


def safe_divide(num: float, den: float, default: float = 0.0) -> float:
    """Safely divide two numbers."""
    return num / den if den != 0 else default


def normal_cdf(x: float) -> float:
    """Approximate the cumulative distribution function of the standard normal.

    Uses the Abramowitz and Stegun approximation (error < 1.5e-7).
    """
    sign = 1 if x >= 0 else -1
    x = abs(x)
    t = 1.0 / (1.0 + 0.2316419 * x)
    d = 0.3989422804014327  # 1/sqrt(2*pi)
    poly = t * (0.319381530 + t * (-0.356563782 + t * (1.781477937 + t * (-1.821255978 + t * 1.330274429))))
    cdf = 1.0 - d * math.exp(-x * x / 2.0) * poly
    return 0.5 + sign * (cdf - 0.5)


def calculate_z_score(p1: float, p2: float, n1: int, n2: int) -> float:
    """Calculate Z-score for two-proportion Z-test."""
    p_pool = safe_divide(p1 * n1 + p2 * n2, n1 + n2)
    se = math.sqrt(p_pool * (1 - p_pool) * (1.0 / n1 + 1.0 / n2)) if p_pool > 0 and p_pool < 1 else 0
    if se == 0:
        return 0.0
    return (p2 - p1) / se


def analyze_test(data: dict) -> dict:
    """Analyze an A/B test for statistical significance."""
    tests = data.get("tests", [data]) if "tests" not in data else data["tests"]

    results = []
    for test in tests:
        control = test.get("control", {})
        variant = test.get("variant", {})

        c_impressions = control.get("impressions", 0)
        c_conversions = control.get("conversions", 0)
        v_impressions = variant.get("impressions", 0)
        v_conversions = variant.get("conversions", 0)

        c_rate = safe_divide(c_conversions, c_impressions) * 100
        v_rate = safe_divide(v_conversions, v_impressions) * 100
        absolute_lift = v_rate - c_rate
        relative_lift = safe_divide(absolute_lift, c_rate) * 100

        # Statistical significance
        c_prop = safe_divide(c_conversions, c_impressions)
        v_prop = safe_divide(v_conversions, v_impressions)
        z_score = calculate_z_score(c_prop, v_prop, c_impressions, v_impressions)
        p_value = 2 * (1 - normal_cdf(abs(z_score)))  # Two-tailed
        confidence = (1 - p_value) * 100

        # Sample size check
        min_sample = 1000  # Minimum per variant for popup tests
        sufficient_sample = c_impressions >= min_sample and v_impressions >= min_sample

        # Recommendation
        if confidence >= 95 and absolute_lift > 0 and sufficient_sample:
            recommendation = "Ship Variant"
            reason = f"Variant wins with {confidence:.1f}% confidence and +{absolute_lift:.2f}pp lift"
        elif confidence >= 95 and absolute_lift < 0 and sufficient_sample:
            recommendation = "Keep Control"
            reason = f"Control wins with {confidence:.1f}% confidence"
        elif not sufficient_sample:
            needed = max(min_sample - c_impressions, min_sample - v_impressions, 0)
            recommendation = "Continue Testing"
            reason = f"Need ~{needed:,} more impressions per variant (minimum {min_sample:,} each)"
        elif confidence < 80:
            recommendation = "Continue Testing"
            reason = f"Only {confidence:.1f}% confidence -- need more data or larger effect size"
        else:
            recommendation = "Continue Testing"
            reason = f"At {confidence:.1f}% confidence -- approaching significance but not yet actionable"

        # Check bounce rate impact
        bounce_warning = None
        c_bounce = control.get("bounce_rate_pct")
        v_bounce = variant.get("bounce_rate_pct")
        if c_bounce is not None and v_bounce is not None:
            bounce_diff = v_bounce - c_bounce
            if bounce_diff > 5:
                bounce_warning = f"Variant increases bounce rate by {bounce_diff:.1f}pp -- conversion win may be a net negative"
                if recommendation == "Ship Variant":
                    recommendation = "Investigate Further"
                    reason += f" BUT bounce rate increased {bounce_diff:.1f}pp"

        test_result = {
            "test_name": test.get("name", "Unnamed Test"),
            "control": {
                "impressions": c_impressions,
                "conversions": c_conversions,
                "conversion_rate_pct": round(c_rate, 3),
            },
            "variant": {
                "impressions": v_impressions,
                "conversions": v_conversions,
                "conversion_rate_pct": round(v_rate, 3),
            },
            "analysis": {
                "absolute_lift_pp": round(absolute_lift, 3),
                "relative_lift_pct": round(relative_lift, 2),
                "z_score": round(z_score, 4),
                "p_value": round(p_value, 6),
                "confidence_pct": round(confidence, 2),
                "sufficient_sample": sufficient_sample,
            },
            "recommendation": recommendation,
            "reason": reason,
        }

        if bounce_warning:
            test_result["bounce_warning"] = bounce_warning

        results.append(test_result)

    return {"test_results": results}


def format_text(result: dict) -> str:
    """Format test results as human-readable text."""
    lines = []

    lines.append("=" * 60)
    lines.append("POPUP A/B TEST ANALYSIS")
    lines.append("=" * 60)

    for tr in result["test_results"]:
        lines.append("")
        lines.append(f"Test: {tr['test_name']}")
        lines.append("-" * 40)

        c = tr["control"]
        v = tr["variant"]
        a = tr["analysis"]

        lines.append(f"  Control:  {c['impressions']:>8,} impressions  |  {c['conversions']:>6,} conversions  |  {c['conversion_rate_pct']:.3f}%")
        lines.append(f"  Variant:  {v['impressions']:>8,} impressions  |  {v['conversions']:>6,} conversions  |  {v['conversion_rate_pct']:.3f}%")
        lines.append("")
        lines.append(f"  Absolute Lift: {a['absolute_lift_pp']:+.3f}pp")
        lines.append(f"  Relative Lift: {a['relative_lift_pct']:+.2f}%")
        lines.append(f"  Confidence: {a['confidence_pct']:.2f}%")
        lines.append(f"  p-value: {a['p_value']:.6f}")
        lines.append(f"  Sufficient Sample: {'Yes' if a['sufficient_sample'] else 'No'}")
        lines.append("")
        lines.append(f"  >> RECOMMENDATION: {tr['recommendation']}")
        lines.append(f"     {tr['reason']}")

        if "bounce_warning" in tr:
            lines.append(f"  >> WARNING: {tr['bounce_warning']}")

    lines.append("")
    return "\n".join(lines)


def main() -> None:
    """Main entry point."""
    parser = argparse.ArgumentParser(
        description="Calculate statistical significance for popup A/B tests."
    )
    parser.add_argument(
        "input_file",
        help="Path to JSON file with A/B test data",
    )
    parser.add_argument(
        "--format",
        choices=["text", "json"],
        default="text",
        help="Output format (default: text)",
    )
    args = parser.parse_args()

    try:
        with open(args.input_file, "r") as f:
            data = json.load(f)
    except FileNotFoundError:
        print(f"Error: File not found: {args.input_file}", file=sys.stderr)
        sys.exit(1)
    except json.JSONDecodeError as e:
        print(f"Error: Invalid JSON: {e}", file=sys.stderr)
        sys.exit(1)

    result = analyze_test(data)

    if args.format == "json":
        print(json.dumps(result, indent=2))
    else:
        print(format_text(result))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Popup ROI Estimator - Estimate revenue impact of popup lead capture.

Models lead volume, conversion pipeline, and customer lifetime value to estimate
popup program ROI. Compares popup-sourced leads against other acquisition channels.

Usage:
    python popup_roi_estimator.py roi_data.json
    python popup_roi_estimator.py roi_data.json --format json
"""

import argparse
import json
import sys
from typing import Any


def safe_divide(num: float, den: float, default: float = 0.0) -> float:
    """Safely divide two numbers."""
    return num / den if den != 0 else default


def estimate_popup_roi(data: dict) -> dict:
    """Estimate ROI from popup lead capture program."""
    popup = data.get("popup_performance", {})
    business = data.get("business_metrics", {})
    channels = data.get("other_channels", [])

    # Core popup metrics
    monthly_visitors = popup.get("monthly_visitors", 0)
    popup_view_rate = popup.get("popup_view_rate_pct", 50) / 100
    popup_conversion_rate = popup.get("popup_conversion_rate_pct", 3) / 100
    lead_to_customer_rate = popup.get("lead_to_customer_rate_pct", 5) / 100

    # Business metrics
    avg_ltv = business.get("avg_customer_ltv", 0)
    avg_order_value = business.get("avg_order_value", 0)
    monthly_popup_cost = business.get("monthly_popup_tool_cost", 0)

    # Calculate pipeline
    monthly_impressions = int(monthly_visitors * popup_view_rate)
    monthly_leads = int(monthly_impressions * popup_conversion_rate)
    monthly_customers = int(monthly_leads * lead_to_customer_rate)

    # Revenue calculation
    if avg_ltv > 0:
        monthly_revenue = monthly_customers * avg_ltv
        revenue_metric = "LTV-based"
    elif avg_order_value > 0:
        monthly_revenue = monthly_customers * avg_order_value
        revenue_metric = "AOV-based"
    else:
        monthly_revenue = 0
        revenue_metric = "No revenue metric provided"

    annual_revenue = monthly_revenue * 12
    annual_cost = monthly_popup_cost * 12

    # Cost per lead and CAC
    cost_per_lead = safe_divide(monthly_popup_cost, monthly_leads)
    popup_cac = safe_divide(monthly_popup_cost, monthly_customers)

    # ROI
    monthly_profit = monthly_revenue - monthly_popup_cost
    annual_profit = annual_revenue - annual_cost
    roi_pct = safe_divide(annual_profit, annual_cost) * 100

    popup_analysis = {
        "pipeline": {
            "monthly_visitors": monthly_visitors,
            "monthly_impressions": monthly_impressions,
            "monthly_leads": monthly_leads,
            "monthly_customers": monthly_customers,
            "popup_view_rate_pct": round(popup_view_rate * 100, 2),
            "popup_conversion_rate_pct": round(popup_conversion_rate * 100, 2),
            "lead_to_customer_rate_pct": round(lead_to_customer_rate * 100, 2),
        },
        "revenue": {
            "revenue_metric": revenue_metric,
            "monthly_revenue": round(monthly_revenue, 2),
            "annual_revenue": round(annual_revenue, 2),
            "monthly_cost": round(monthly_popup_cost, 2),
            "annual_cost": round(annual_cost, 2),
            "monthly_profit": round(monthly_profit, 2),
            "annual_profit": round(annual_profit, 2),
            "roi_pct": round(roi_pct, 1),
        },
        "unit_economics": {
            "cost_per_lead": round(cost_per_lead, 2),
            "popup_cac": round(popup_cac, 2),
            "ltv_to_cac_ratio": round(safe_divide(avg_ltv, popup_cac), 2) if popup_cac > 0 else "N/A",
        },
    }

    # Channel comparison
    channel_comparison = []
    for ch in channels:
        ch_leads = ch.get("monthly_leads", 0)
        ch_cost = ch.get("monthly_cost", 0)
        ch_customers = ch.get("monthly_customers", 0)
        ch_cpl = safe_divide(ch_cost, ch_leads)
        ch_cac = safe_divide(ch_cost, ch_customers)
        ch_ltv_cac = safe_divide(avg_ltv, ch_cac) if ch_cac > 0 else 0

        channel_comparison.append({
            "channel": ch.get("name", "Unknown"),
            "monthly_leads": ch_leads,
            "monthly_customers": ch_customers,
            "cost_per_lead": round(ch_cpl, 2),
            "cac": round(ch_cac, 2),
            "ltv_to_cac": round(ch_ltv_cac, 2),
        })

    # Add popup as a channel for comparison
    channel_comparison.insert(0, {
        "channel": "Popup Lead Capture",
        "monthly_leads": monthly_leads,
        "monthly_customers": monthly_customers,
        "cost_per_lead": round(cost_per_lead, 2),
        "cac": round(popup_cac, 2),
        "ltv_to_cac": round(safe_divide(avg_ltv, popup_cac), 2) if popup_cac > 0 else 0,
    })

    # Improvement scenarios
    scenarios = []
    for improvement_name, new_rate in [
        ("Optimized copy (+50% conversion)", popup_conversion_rate * 1.5),
        ("Added countdown timer (+46% per benchmarks)", popup_conversion_rate * 1.46),
        ("Gamified popup (+3x per benchmarks)", popup_conversion_rate * 3),
    ]:
        new_leads = int(monthly_impressions * new_rate)
        new_customers = int(new_leads * lead_to_customer_rate)
        new_revenue = new_customers * (avg_ltv if avg_ltv > 0 else avg_order_value)
        scenarios.append({
            "scenario": improvement_name,
            "new_conversion_rate_pct": round(new_rate * 100, 2),
            "monthly_leads": new_leads,
            "monthly_customers": new_customers,
            "monthly_revenue": round(new_revenue, 2),
            "incremental_monthly_revenue": round(new_revenue - monthly_revenue, 2),
        })

    return {
        "popup_analysis": popup_analysis,
        "channel_comparison": channel_comparison,
        "improvement_scenarios": scenarios,
    }


def format_text(result: dict) -> str:
    """Format ROI estimate as human-readable text."""
    lines = []
    pa = result["popup_analysis"]

    lines.append("=" * 60)
    lines.append("POPUP ROI ESTIMATE")
    lines.append("=" * 60)
    lines.append("")

    p = pa["pipeline"]
    lines.append("-" * 40)
    lines.append("LEAD PIPELINE")
    lines.append("-" * 40)
    lines.append(f"  Monthly Visitors:    {p['monthly_visitors']:>10,}")
    lines.append(f"  Popup Impressions:   {p['monthly_impressions']:>10,}  ({p['popup_view_rate_pct']}% view rate)")
    lines.append(f"  Leads Captured:      {p['monthly_leads']:>10,}  ({p['popup_conversion_rate_pct']}% conversion)")
    lines.append(f"  New Customers:       {p['monthly_customers']:>10,}  ({p['lead_to_customer_rate_pct']}% lead-to-customer)")
    lines.append("")

    r = pa["revenue"]
    lines.append("-" * 40)
    lines.append(f"REVENUE ({r['revenue_metric']})")
    lines.append("-" * 40)
    lines.append(f"  Monthly Revenue:     ${r['monthly_revenue']:>12,.2f}")
    lines.append(f"  Annual Revenue:      ${r['annual_revenue']:>12,.2f}")
    lines.append(f"  Monthly Cost:        ${r['monthly_cost']:>12,.2f}")
    lines.append(f"  Annual Profit:       ${r['annual_profit']:>12,.2f}")
    lines.append(f"  ROI:                 {r['roi_pct']:>12.1f}%")
    lines.append("")

    u = pa["unit_economics"]
    lines.append("-" * 40)
    lines.append("UNIT ECONOMICS")
    lines.append("-" * 40)
    lines.append(f"  Cost per Lead:       ${u['cost_per_lead']:>12,.2f}")
    lines.append(f"  Popup CAC:           ${u['popup_cac']:>12,.2f}")
    lines.append(f"  LTV:CAC Ratio:       {u['ltv_to_cac_ratio']}:1" if isinstance(u['ltv_to_cac_ratio'], (int, float)) else f"  LTV:CAC Ratio:       {u['ltv_to_cac_ratio']}")
    lines.append("")

    if result["channel_comparison"]:
        lines.append("-" * 40)
        lines.append("CHANNEL COMPARISON")
        lines.append("-" * 40)
        for ch in result["channel_comparison"]:
            lines.append(f"  {ch['channel']:<25} Leads: {ch['monthly_leads']:>5,}  CAC: ${ch['cac']:>8,.2f}  LTV:CAC: {ch['ltv_to_cac']:.1f}x")
        lines.append("")

    if result["improvement_scenarios"]:
        lines.append("-" * 40)
        lines.append("IMPROVEMENT SCENARIOS")
        lines.append("-" * 40)
        for sc in result["improvement_scenarios"]:
            lines.append(f"\n  {sc['scenario']}")
            lines.append(f"    Conv Rate: {sc['new_conversion_rate_pct']}%  |  Leads: {sc['monthly_leads']:,}  |  Revenue: ${sc['monthly_revenue']:,.2f}  |  Uplift: ${sc['incremental_monthly_revenue']:+,.2f}/mo")

    lines.append("")
    return "\n".join(lines)


def main() -> None:
    """Main entry point."""
    parser = argparse.ArgumentParser(
        description="Estimate revenue impact of popup lead capture program."
    )
    parser.add_argument(
        "input_file",
        help="Path to JSON file with popup performance and revenue data",
    )
    parser.add_argument(
        "--format",
        choices=["text", "json"],
        default="text",
        help="Output format (default: text)",
    )
    args = parser.parse_args()

    try:
        with open(args.input_file, "r") as f:
            data = json.load(f)
    except FileNotFoundError:
        print(f"Error: File not found: {args.input_file}", file=sys.stderr)
        sys.exit(1)
    except json.JSONDecodeError as e:
        print(f"Error: Invalid JSON: {e}", file=sys.stderr)
        sys.exit(1)

    result = estimate_popup_roi(data)

    if args.format == "json":
        print(json.dumps(result, indent=2))
    else:
        print(format_text(result))


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Popup Strategy Auditor - Audit popup configurations for compliance and best practices.

Checks popup inventory for frequency conflicts, targeting gaps, mobile safety,
compliance issues (GDPR, CAN-SPAM), and dark pattern risks.

Usage:
    python popup_strategy_auditor.py popups.json
    python popup_strategy_auditor.py popups.json --format json
"""

import argparse
import json
import sys
from typing import Any


MOBILE_SAFE_FORMATS = ["bottom_bar", "top_bar", "slide_in", "inline_expansion"]
MOBILE_UNSAFE_FORMATS = ["full_screen_overlay"]

VALID_FORMATS = [
    "center_modal", "slide_in", "top_bar", "bottom_bar",
    "full_screen_overlay", "inline_expansion", "exit_intent_modal",
]

VALID_TRIGGERS = [
    "exit_intent", "time_delay", "scroll_depth", "page_count",
    "click_trigger", "inactivity", "entry",
]

COMPLIANCE_REQUIREMENTS = {
    "gdpr": ["consent_checkbox", "privacy_link", "data_purpose"],
    "ccpa": ["do_not_sell_link", "privacy_policy"],
    "can_spam": ["unsubscribe_mechanism", "physical_address"],
}

SHAME_PHRASES = [
    "no, i don't want to",
    "no thanks, i prefer",
    "i don't need",
    "i hate saving",
]


def audit_single_popup(popup: dict, index: int) -> list[dict]:
    """Audit a single popup configuration."""
    issues = []
    popup_id = popup.get("id", f"popup_{index}")

    # Format validation
    fmt = popup.get("format", "")
    if fmt and fmt not in VALID_FORMATS:
        issues.append({
            "popup_id": popup_id,
            "category": "configuration",
            "severity": "warning",
            "issue": f"Unknown format: {fmt}",
            "fix": f"Use one of: {', '.join(VALID_FORMATS)}",
        })

    # Mobile safety
    if fmt in MOBILE_UNSAFE_FORMATS and popup.get("show_on_mobile", True):
        issues.append({
            "popup_id": popup_id,
            "category": "mobile",
            "severity": "error",
            "issue": f"Format '{fmt}' is not mobile-safe and will trigger Google penalty",
            "fix": "Set show_on_mobile to false or switch to a mobile-safe format (slide_in, bottom_bar)",
        })

    # Trigger validation
    trigger = popup.get("trigger", "")
    if trigger == "exit_intent" and popup.get("show_on_mobile", True):
        issues.append({
            "popup_id": popup_id,
            "category": "mobile",
            "severity": "warning",
            "issue": "Exit intent trigger does not work on mobile devices",
            "fix": "Add mobile-specific trigger (scroll_up, inactivity) or disable popup on mobile",
        })

    # Time delay check
    if trigger == "time_delay":
        delay = popup.get("delay_seconds", 0)
        if delay < 10:
            issues.append({
                "popup_id": popup_id,
                "category": "timing",
                "severity": "warning",
                "issue": f"Time delay of {delay}s is too aggressive (< 10s)",
                "fix": "Set delay to 15-30 seconds for optimal balance",
            })

    # Frequency caps
    max_per_session = popup.get("max_per_session")
    if max_per_session is not None and max_per_session > 1:
        issues.append({
            "popup_id": popup_id,
            "category": "frequency",
            "severity": "warning",
            "issue": f"Allows {max_per_session} impressions per session (should be max 1)",
            "fix": "Limit to 1 popup impression per session",
        })

    cooldown = popup.get("cooldown_days", 0)
    if cooldown < 3:
        issues.append({
            "popup_id": popup_id,
            "category": "frequency",
            "severity": "warning",
            "issue": f"Cooldown of {cooldown} days is too short after dismissal",
            "fix": "Set cooldown to minimum 7 days after dismissal",
        })

    # Exclusion rules
    if not popup.get("exclude_converted_users", False):
        issues.append({
            "popup_id": popup_id,
            "category": "targeting",
            "severity": "error",
            "issue": "Not excluding users who already converted",
            "fix": "Always suppress popup for users who have already subscribed/purchased/signed up",
        })

    if not popup.get("exclude_checkout_flow", False):
        issues.append({
            "popup_id": popup_id,
            "category": "targeting",
            "severity": "error",
            "issue": "Popup may appear during checkout flow",
            "fix": "Exclude checkout and payment pages from popup targeting",
        })

    # Decline text dark pattern check
    decline_text = popup.get("decline_text", "").lower()
    for phrase in SHAME_PHRASES:
        if phrase in decline_text:
            issues.append({
                "popup_id": popup_id,
                "category": "dark_pattern",
                "severity": "error",
                "issue": f"Shame language in decline text: '{popup.get('decline_text')}'",
                "fix": "Use neutral text: 'No thanks', 'Maybe later', 'Not now'",
            })
            break

    # Close button
    if popup.get("close_button_visible") is False:
        issues.append({
            "popup_id": popup_id,
            "category": "dark_pattern",
            "severity": "error",
            "issue": "Close button is hidden",
            "fix": "Close button must be clearly visible with minimum 44x44px touch target on mobile",
        })

    # Compliance checks
    if popup.get("captures_email", False):
        compliance_regions = popup.get("target_regions", [])
        for region, requirements in COMPLIANCE_REQUIREMENTS.items():
            if not compliance_regions or region in compliance_regions:
                compliance_features = popup.get("compliance", {})
                for req in requirements:
                    if not compliance_features.get(req, False):
                        issues.append({
                            "popup_id": popup_id,
                            "category": "compliance",
                            "severity": "error",
                            "issue": f"Missing {region.upper()} requirement: {req.replace('_', ' ')}",
                            "fix": f"Add {req.replace('_', ' ')} to comply with {region.upper()} regulations",
                        })

    return issues


def check_conflicts(popups: list[dict]) -> list[dict]:
    """Check for conflicts between multiple popups."""
    issues = []

    # Check for overlapping triggers on same pages
    page_popups: dict[str, list] = {}
    for popup in popups:
        for page in popup.get("target_pages", ["all"]):
            page_popups.setdefault(page, []).append(popup)

    for page, page_popup_list in page_popups.items():
        if len(page_popup_list) > 2:
            popup_ids = [p.get("id", "unknown") for p in page_popup_list]
            issues.append({
                "popup_id": "system",
                "category": "conflict",
                "severity": "warning",
                "issue": f"Page '{page}' has {len(page_popup_list)} popups configured: {', '.join(popup_ids)}",
                "fix": "Implement priority queue -- max 1 marketing popup per session after legal popups",
            })

    # Check for missing cookie consent priority
    has_cookie_consent = any(p.get("type") == "cookie_consent" for p in popups)
    has_marketing = any(p.get("type") != "cookie_consent" for p in popups)
    if has_marketing and not has_cookie_consent:
        issues.append({
            "popup_id": "system",
            "category": "compliance",
            "severity": "warning",
            "issue": "Marketing popups configured but no cookie consent popup found",
            "fix": "Add cookie consent popup with highest priority if targeting EU/UK users",
        })

    return issues


def audit_popups(data: dict) -> dict:
    """Run full popup audit."""
    popups = data.get("popups", [])

    all_issues = []
    for i, popup in enumerate(popups):
        all_issues.extend(audit_single_popup(popup, i))

    all_issues.extend(check_conflicts(popups))

    error_count = sum(1 for i in all_issues if i["severity"] == "error")
    warning_count = sum(1 for i in all_issues if i["severity"] == "warning")

    # Category summary
    categories = {}
    for issue in all_issues:
        cat = issue["category"]
        categories.setdefault(cat, {"errors": 0, "warnings": 0})
        categories[cat]["errors" if issue["severity"] == "error" else "warnings"] += 1

    if error_count == 0 and warning_count <= 2:
        health = "Healthy"
    elif error_count <= 3:
        health = "Needs Attention"
    else:
        health = "Critical"

    return {
        "summary": {
            "total_popups": len(popups),
            "total_issues": len(all_issues),
            "errors": error_count,
            "warnings": warning_count,
            "health_rating": health,
        },
        "category_summary": categories,
        "issues": all_issues,
    }


def format_text(result: dict) -> str:
    """Format audit results as human-readable text."""
    lines = []
    summary = result["summary"]

    lines.append("=" * 60)
    lines.append("POPUP STRATEGY AUDIT REPORT")
    lines.append("=" * 60)
    lines.append("")
    lines.append(f"Health Rating: {summary['health_rating']}")
    lines.append(f"Total Popups: {summary['total_popups']}")
    lines.append(f"Issues: {summary['total_issues']} ({summary['errors']} errors, {summary['warnings']} warnings)")
    lines.append("")

    if result["category_summary"]:
        lines.append("-" * 40)
        lines.append("ISSUES BY CATEGORY")
        lines.append("-" * 40)
        for cat, counts in sorted(result["category_summary"].items()):
            lines.append(f"  {cat}: {counts['errors']} errors, {counts['warnings']} warnings")
        lines.append("")

    if result["issues"]:
        lines.append("-" * 40)
        lines.append("DETAILED ISSUES")
        lines.append("-" * 40)
        for issue in result["issues"]:
            severity = "[ERROR]" if issue["severity"] == "error" else "[WARN]"
            lines.append(f"\n{severity} [{issue['category']}] {issue['popup_id']}")
            lines.append(f"  Issue: {issue['issue']}")
            lines.append(f"  Fix: {issue['fix']}")
    else:
        lines.append("No issues found.")

    lines.append("")
    return "\n".join(lines)


def main() -> None:
    """Main entry point."""
    parser = argparse.ArgumentParser(
        description="Audit popup configurations for compliance, frequency, and best practices."
    )
    parser.add_argument(
        "input_file",
        help="Path to JSON file with popup inventory",
    )
    parser.add_argument(
        "--format",
        choices=["text", "json"],
        default="text",
        help="Output format (default: text)",
    )
    args = parser.parse_args()

    try:
        with open(args.input_file, "r") as f:
            data = json.load(f)
    except FileNotFoundError:
        print(f"Error: File not found: {args.input_file}", file=sys.stderr)
        sys.exit(1)
    except json.JSONDecodeError as e:
        print(f"Error: Invalid JSON: {e}", file=sys.stderr)
        sys.exit(1)

    result = audit_popups(data)

    if args.format == "json":
        print(json.dumps(result, indent=2))
    else:
        print(format_text(result))


if __name__ == "__main__":
    main()