Churn Prevention

#!/usr/bin/env python3
"""
Churn Impact Calculator

Calculate the revenue impact of churn reduction at various improvement levels.
Models voluntary churn savings, involuntary churn recovery, and cancel flow
save rate contributions to annual revenue retention.

Usage:
    python churn_impact_calculator.py --mrr 500000 --churn-rate 4.0 --save-rate 20
    python churn_impact_calculator.py --mrr 500000 --churn-rate 4.0 --save-rate 20 --json
"""

import argparse
import json
import sys


def calculate_impact(mrr: float, churn_rate: float, save_rate: float,
                     target_churn: float) -> dict:
    """Calculate revenue impact of churn reduction."""
    monthly_mrr_lost = mrr * (churn_rate / 100.0)
    annual_mrr_lost = monthly_mrr_lost * 12

    # Impact of reducing churn rate to target
    reduction_pct = churn_rate - target_churn
    monthly_savings_from_reduction = mrr * (reduction_pct / 100.0)
    annual_savings_from_reduction = monthly_savings_from_reduction * 12

    # Impact of save rate on remaining churn
    remaining_monthly_churn = mrr * (target_churn / 100.0)
    monthly_savings_from_saves = remaining_monthly_churn * (save_rate / 100.0)
    annual_savings_from_saves = monthly_savings_from_saves * 12

    total_annual_impact = annual_savings_from_reduction + annual_savings_from_saves

    # Scenario modeling at different improvement levels
    scenarios = []
    for improvement in [0.5, 1.0, 1.5, 2.0]:
        new_rate = max(0.1, churn_rate - improvement)
        new_monthly_lost = mrr * (new_rate / 100.0)
        saved = (monthly_mrr_lost - new_monthly_lost) * 12
        scenarios.append({
            "churn_reduction_pct": improvement,
            "new_churn_rate": round(new_rate, 2),
            "annual_mrr_saved": round(saved, 2),
        })

    # Save rate scenarios
    save_scenarios = []
    for sr in [10, 15, 20, 25, 30]:
        monthly_saved = monthly_mrr_lost * (sr / 100.0)
        save_scenarios.append({
            "save_rate_pct": sr,
            "monthly_mrr_saved": round(monthly_saved, 2),
            "annual_mrr_saved": round(monthly_saved * 12, 2),
        })

    # Net Revenue Retention estimate
    nrr = ((mrr - monthly_mrr_lost + monthly_savings_from_reduction +
            monthly_savings_from_saves) / mrr) * 100

    return {
        "inputs": {
            "current_mrr": mrr,
            "current_churn_rate_pct": churn_rate,
            "target_churn_rate_pct": target_churn,
            "save_rate_pct": save_rate,
        },
        "current_state": {
            "monthly_mrr_at_risk": round(monthly_mrr_lost, 2),
            "annual_mrr_at_risk": round(annual_mrr_lost, 2),
            "annual_arr": round(mrr * 12, 2),
            "churn_as_pct_of_arr": round((annual_mrr_lost / (mrr * 12)) * 100, 2),
        },
        "projected_impact": {
            "annual_savings_from_churn_reduction": round(annual_savings_from_reduction, 2),
            "annual_savings_from_save_offers": round(annual_savings_from_saves, 2),
            "total_annual_impact": round(total_annual_impact, 2),
            "estimated_nrr_pct": round(nrr, 2),
        },
        "churn_reduction_scenarios": scenarios,
        "save_rate_scenarios": save_scenarios,
        "recommendations": _generate_recommendations(churn_rate, save_rate, monthly_mrr_lost),
    }


def _generate_recommendations(churn_rate: float, save_rate: float,
                              monthly_lost: float) -> list:
    """Generate actionable recommendations based on inputs."""
    recs = []
    if churn_rate > 5.0:
        recs.append({
            "priority": "CRITICAL",
            "area": "Overall churn",
            "recommendation": "Churn rate above 5% indicates systemic issues beyond cancel flow optimization. Review ICP, product-market fit, and pricing.",
        })
    if churn_rate > 3.0:
        recs.append({
            "priority": "HIGH",
            "area": "Voluntary churn",
            "recommendation": "Implement or optimize cancel flow with exit survey and dynamic save offers. Target 15-25% save rate.",
        })
    if save_rate < 10:
        recs.append({
            "priority": "HIGH",
            "area": "Save rate",
            "recommendation": "Save rate below 10% suggests offers do not match exit reasons. Rebuild reason-to-offer mapping.",
        })
    if save_rate < 20:
        recs.append({
            "priority": "MEDIUM",
            "area": "Save rate",
            "recommendation": "Test stronger save offers: pause option for LOW_USAGE, 30-50% discount for PRICE, free onboarding for COMPLEXITY.",
        })
    recs.append({
        "priority": "MEDIUM",
        "area": "Involuntary churn",
        "recommendation": f"Enable card updater service and optimize dunning. Recovering 30% of failed payments saves ${monthly_lost * 0.3 * 0.3 * 12:,.0f}/year (assuming 30% of churn is involuntary).",
    })
    return recs


def format_text(result: dict) -> str:
    """Format results as human-readable text."""
    lines = []
    lines.append("=" * 60)
    lines.append("CHURN IMPACT CALCULATOR")
    lines.append("=" * 60)

    inp = result["inputs"]
    lines.append(f"\nCurrent MRR:        ${inp['current_mrr']:>12,.2f}")
    lines.append(f"Churn Rate:         {inp['current_churn_rate_pct']:>12.1f}%")
    lines.append(f"Target Churn Rate:  {inp['target_churn_rate_pct']:>12.1f}%")
    lines.append(f"Save Rate:          {inp['save_rate_pct']:>12.1f}%")

    cs = result["current_state"]
    lines.append(f"\n--- Current State ---")
    lines.append(f"Monthly MRR at Risk:   ${cs['monthly_mrr_at_risk']:>12,.2f}")
    lines.append(f"Annual MRR at Risk:    ${cs['annual_mrr_at_risk']:>12,.2f}")
    lines.append(f"Annual ARR:            ${cs['annual_arr']:>12,.2f}")
    lines.append(f"Churn as % of ARR:     {cs['churn_as_pct_of_arr']:>12.1f}%")

    pi = result["projected_impact"]
    lines.append(f"\n--- Projected Impact ---")
    lines.append(f"From Churn Reduction:  ${pi['annual_savings_from_churn_reduction']:>12,.2f}/year")
    lines.append(f"From Save Offers:      ${pi['annual_savings_from_save_offers']:>12,.2f}/year")
    lines.append(f"Total Annual Impact:   ${pi['total_annual_impact']:>12,.2f}/year")
    lines.append(f"Estimated NRR:         {pi['estimated_nrr_pct']:>12.1f}%")

    lines.append(f"\n--- Churn Reduction Scenarios ---")
    lines.append(f"{'Reduction':>10}  {'New Rate':>10}  {'Annual Saved':>14}")
    for s in result["churn_reduction_scenarios"]:
        lines.append(f"{s['churn_reduction_pct']:>9.1f}%  {s['new_churn_rate']:>9.1f}%  ${s['annual_mrr_saved']:>12,.2f}")

    lines.append(f"\n--- Save Rate Scenarios ---")
    lines.append(f"{'Save Rate':>10}  {'Monthly Saved':>14}  {'Annual Saved':>14}")
    for s in result["save_rate_scenarios"]:
        lines.append(f"{s['save_rate_pct']:>9d}%  ${s['monthly_mrr_saved']:>12,.2f}  ${s['annual_mrr_saved']:>12,.2f}")

    lines.append(f"\n--- Recommendations ---")
    for r in result["recommendations"]:
        lines.append(f"[{r['priority']}] {r['area']}: {r['recommendation']}")

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


def main():
    parser = argparse.ArgumentParser(
        description="Calculate revenue impact of churn reduction at various improvement levels."
    )
    parser.add_argument("--mrr", type=float, required=True,
                        help="Current monthly recurring revenue in dollars")
    parser.add_argument("--churn-rate", type=float, required=True,
                        help="Current monthly churn rate as percentage (e.g., 4.0 for 4%%)")
    parser.add_argument("--save-rate", type=float, default=15.0,
                        help="Cancel flow save rate as percentage (default: 15)")
    parser.add_argument("--target-churn", type=float, default=None,
                        help="Target churn rate as percentage (default: current minus 1)")
    parser.add_argument("--json", action="store_true",
                        help="Output results as JSON")

    args = parser.parse_args()

    if args.mrr <= 0:
        print("Error: --mrr must be positive.", file=sys.stderr)
        sys.exit(1)
    if args.churn_rate <= 0 or args.churn_rate > 100:
        print("Error: --churn-rate must be between 0 and 100.", file=sys.stderr)
        sys.exit(1)
    if args.save_rate < 0 or args.save_rate > 100:
        print("Error: --save-rate must be between 0 and 100.", file=sys.stderr)
        sys.exit(1)

    target = args.target_churn if args.target_churn is not None else max(0.1, args.churn_rate - 1.0)

    result = calculate_impact(args.mrr, args.churn_rate, args.save_rate, target)

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Dunning Sequence Analyzer

Analyze dunning email sequence effectiveness and recommend retry timing
optimizations. Calculates recovery rates by failure reason, retry attempt,
and timing window.

Usage:
    python dunning_sequence_analyzer.py dunning_data.json
    python dunning_sequence_analyzer.py dunning_data.json --json
"""

import argparse
import json
import sys
from collections import defaultdict


FAILURE_REASONS = {
    "expired_card": {"recoverable": True, "typical_rate": 0.60},
    "insufficient_funds": {"recoverable": True, "typical_rate": 0.50},
    "bank_decline": {"recoverable": True, "typical_rate": 0.30},
    "account_closed": {"recoverable": False, "typical_rate": 0.05},
    "network_error": {"recoverable": True, "typical_rate": 0.85},
    "fraud_flag": {"recoverable": True, "typical_rate": 0.20},
    "unknown": {"recoverable": True, "typical_rate": 0.35},
}

OPTIMAL_RETRY_SCHEDULE = [
    {"retry": 1, "day": 3, "rationale": "Most card issues resolve within 72 hours"},
    {"retry": 2, "day": 7, "rationale": "Paycheck cycle alignment"},
    {"retry": 3, "day": 12, "rationale": "Second paycheck cycle"},
    {"retry": 4, "day": 18, "rationale": "Final attempt before service action"},
]


def analyze_dunning(data: dict) -> dict:
    """Analyze dunning sequence data."""
    payments = data.get("failed_payments", [])
    if not payments:
        return {"error": "No failed payment data provided."}

    total = len(payments)
    total_amount = sum(p.get("amount", 0) for p in payments)
    recovered_count = 0
    recovered_amount = 0.0

    # By failure reason
    by_reason = defaultdict(lambda: {"total": 0, "recovered": 0, "amount": 0.0, "recovered_amount": 0.0})
    # By retry attempt
    by_retry = defaultdict(lambda: {"attempts": 0, "recovered": 0})
    # Recovery timing
    recovery_days = []

    for p in payments:
        reason = p.get("failure_reason", "unknown")
        amount = p.get("amount", 0)
        retries = p.get("retry_attempts", [])

        by_reason[reason]["total"] += 1
        by_reason[reason]["amount"] += amount

        payment_recovered = False
        for i, retry in enumerate(retries):
            by_retry[i]["attempts"] += 1
            if retry.get("recovered", False) and not payment_recovered:
                payment_recovered = True
                recovered_count += 1
                recovered_amount += amount
                by_reason[reason]["recovered"] += 1
                by_reason[reason]["recovered_amount"] += amount
                by_retry[i]["recovered"] += 1
                recovery_days.append(retry.get("day", 0))

    # Build reason breakdown
    reason_breakdown = []
    for reason, stats in sorted(by_reason.items(), key=lambda x: x[1]["total"], reverse=True):
        rate = (stats["recovered"] / stats["total"] * 100) if stats["total"] > 0 else 0
        benchmark = FAILURE_REASONS.get(reason, {})
        typical = benchmark.get("typical_rate", 0.35) * 100
        reason_breakdown.append({
            "reason": reason,
            "total_failures": stats["total"],
            "recovered": stats["recovered"],
            "recovery_rate_pct": round(rate, 1),
            "amount_at_risk": round(stats["amount"], 2),
            "amount_recovered": round(stats["recovered_amount"], 2),
            "benchmark_recovery_pct": round(typical, 1),
            "vs_benchmark": "above" if rate > typical else "below" if rate < typical else "at",
            "recoverable": benchmark.get("recoverable", True),
        })

    # Build retry breakdown
    retry_breakdown = []
    for attempt in sorted(by_retry.keys()):
        stats = by_retry[attempt]
        rate = (stats["recovered"] / stats["attempts"] * 100) if stats["attempts"] > 0 else 0
        retry_breakdown.append({
            "attempt": attempt + 1,
            "total_attempts": stats["attempts"],
            "recovered": stats["recovered"],
            "recovery_rate_pct": round(rate, 1),
        })

    overall_rate = (recovered_count / total * 100) if total > 0 else 0
    avg_recovery_day = (sum(recovery_days) / len(recovery_days)) if recovery_days else 0

    # Recommendations
    recommendations = _generate_recommendations(overall_rate, reason_breakdown, retry_breakdown)

    return {
        "summary": {
            "total_failed_payments": total,
            "total_amount_at_risk": round(total_amount, 2),
            "recovered_count": recovered_count,
            "recovered_amount": round(recovered_amount, 2),
            "overall_recovery_rate_pct": round(overall_rate, 1),
            "average_recovery_day": round(avg_recovery_day, 1),
            "unrecovered_count": total - recovered_count,
            "unrecovered_amount": round(total_amount - recovered_amount, 2),
        },
        "by_failure_reason": reason_breakdown,
        "by_retry_attempt": retry_breakdown,
        "optimal_retry_schedule": OPTIMAL_RETRY_SCHEDULE,
        "recommendations": recommendations,
    }


def _generate_recommendations(overall_rate: float, reasons: list, retries: list) -> list:
    """Generate recommendations based on analysis."""
    recs = []

    if overall_rate < 20:
        recs.append({
            "priority": "CRITICAL",
            "area": "Overall recovery",
            "recommendation": "Recovery rate below 20% indicates dunning system is underperforming. Audit email delivery, retry schedule, and payment update UX.",
        })
    elif overall_rate < 35:
        recs.append({
            "priority": "HIGH",
            "area": "Overall recovery",
            "recommendation": "Recovery rate below benchmark (35%). Review retry timing and add in-app payment update prompts.",
        })

    for r in reasons:
        if r["reason"] == "expired_card" and r["recovery_rate_pct"] < 50:
            recs.append({
                "priority": "HIGH",
                "area": "Card updates",
                "recommendation": "Expired card recovery is low. Enable automatic card updater service on your payment processor (Stripe, Braintree, etc.).",
            })
        if r["reason"] == "insufficient_funds" and r["recovery_rate_pct"] < 40:
            recs.append({
                "priority": "MEDIUM",
                "area": "Retry timing",
                "recommendation": "Insufficient funds recovery is low. Ensure retries align with common paycheck dates (1st, 15th of month).",
            })

    if len(retries) < 4:
        recs.append({
            "priority": "MEDIUM",
            "area": "Retry attempts",
            "recommendation": f"Only {len(retries)} retry attempts configured. Best practice is 4 retries over 18 days before service action.",
        })

    recs.append({
        "priority": "MEDIUM",
        "area": "Dunning emails",
        "recommendation": "Ensure every dunning email links directly to the payment update page (not the dashboard). Include amount owed and card last 4 digits.",
    })

    return recs


def format_text(result: dict) -> str:
    """Format results as human-readable text."""
    lines = []
    lines.append("=" * 60)
    lines.append("DUNNING SEQUENCE ANALYZER")
    lines.append("=" * 60)

    s = result["summary"]
    lines.append(f"\n--- Summary ---")
    lines.append(f"Total Failed Payments:    {s['total_failed_payments']:>8d}")
    lines.append(f"Total Amount at Risk:     ${s['total_amount_at_risk']:>12,.2f}")
    lines.append(f"Recovered:                {s['recovered_count']:>8d}  (${s['recovered_amount']:>10,.2f})")
    lines.append(f"Unrecovered:              {s['unrecovered_count']:>8d}  (${s['unrecovered_amount']:>10,.2f})")
    lines.append(f"Overall Recovery Rate:    {s['overall_recovery_rate_pct']:>8.1f}%")
    lines.append(f"Avg Recovery Day:         {s['average_recovery_day']:>8.1f}")

    lines.append(f"\n--- By Failure Reason ---")
    lines.append(f"{'Reason':<20} {'Total':>6} {'Recovered':>10} {'Rate':>8} {'Benchmark':>10} {'Status':>8}")
    for r in result["by_failure_reason"]:
        lines.append(f"{r['reason']:<20} {r['total_failures']:>6d} {r['recovered']:>10d} {r['recovery_rate_pct']:>7.1f}% {r['benchmark_recovery_pct']:>9.1f}% {r['vs_benchmark']:>8}")

    lines.append(f"\n--- By Retry Attempt ---")
    lines.append(f"{'Attempt':>8} {'Tried':>8} {'Recovered':>10} {'Rate':>8}")
    for r in result["by_retry_attempt"]:
        lines.append(f"{r['attempt']:>8d} {r['total_attempts']:>8d} {r['recovered']:>10d} {r['recovery_rate_pct']:>7.1f}%")

    lines.append(f"\n--- Optimal Retry Schedule ---")
    for r in result["optimal_retry_schedule"]:
        lines.append(f"  Retry {r['retry']}: Day {r['day']:>2d} -- {r['rationale']}")

    lines.append(f"\n--- Recommendations ---")
    for r in result["recommendations"]:
        lines.append(f"[{r['priority']}] {r['area']}: {r['recommendation']}")

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


def main():
    parser = argparse.ArgumentParser(
        description="Analyze dunning email sequence effectiveness and recommend optimizations."
    )
    parser.add_argument("input_file", help="JSON file with failed payment and retry data")
    parser.add_argument("--json", action="store_true", help="Output results as JSON")

    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 in {args.input_file}: {e}", file=sys.stderr)
        sys.exit(1)

    result = analyze_dunning(data)

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


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Exit Survey Analyzer

Analyze exit survey responses to identify churn patterns, save offer
effectiveness, and systemic issues. Produces reason distribution, save
rate analysis, trend detection, and competitive intelligence.

Usage:
    python exit_survey_analyzer.py survey_data.json
    python exit_survey_analyzer.py survey_data.json --json
    python exit_survey_analyzer.py survey_data.json --period "Q1 2026"
"""

import argparse
import json
import sys
from collections import defaultdict


EXIT_REASONS = ["PRICE", "LOW_USAGE", "MISSING_FEATURE", "COMPETITOR",
                "PROJECT_END", "COMPLEXITY", "TESTING", "OTHER"]

BENCHMARKS = {
    "save_rate_good": 15.0,
    "save_rate_excellent": 25.0,
    "survey_completion_good": 70.0,
    "survey_completion_excellent": 90.0,
    "reason_concentration_warning": 30.0,
    "reason_concentration_critical": 40.0,
}


def analyze_surveys(data: dict, period: str) -> dict:
    """Analyze exit survey data."""
    responses = data.get("responses", [])
    if not responses:
        return {"error": "No survey response data provided."}

    total_cancel_attempts = data.get("total_cancel_attempts", len(responses))
    total_responses = len(responses)

    # Reason distribution
    by_reason = defaultdict(lambda: {
        "count": 0, "saved": 0, "mrr_at_risk": 0.0, "mrr_saved": 0.0,
        "competitors_mentioned": defaultdict(int), "features_requested": defaultdict(int),
    })

    for r in responses:
        reason = r.get("reason", "OTHER")
        if reason not in EXIT_REASONS:
            reason = "OTHER"

        by_reason[reason]["count"] += 1
        by_reason[reason]["mrr_at_risk"] += r.get("mrr", 0)

        if r.get("saved", False):
            by_reason[reason]["saved"] += 1
            by_reason[reason]["mrr_saved"] += r.get("mrr", 0)

        if reason == "COMPETITOR" and r.get("competitor_name"):
            by_reason[reason]["competitors_mentioned"][r["competitor_name"]] += 1

        if reason == "MISSING_FEATURE" and r.get("feature_name"):
            by_reason[reason]["features_requested"][r["feature_name"]] += 1

    # Build reason breakdown
    reason_breakdown = []
    total_saved = sum(d["saved"] for d in by_reason.values())
    total_mrr_risk = sum(d["mrr_at_risk"] for d in by_reason.values())
    total_mrr_saved = sum(d["mrr_saved"] for d in by_reason.values())

    for reason in EXIT_REASONS:
        stats = by_reason[reason]
        if stats["count"] == 0:
            continue
        pct = (stats["count"] / total_responses * 100) if total_responses > 0 else 0
        save_rate = (stats["saved"] / stats["count"] * 100) if stats["count"] > 0 else 0
        reason_breakdown.append({
            "reason": reason,
            "count": stats["count"],
            "percentage": round(pct, 1),
            "saved": stats["saved"],
            "save_rate_pct": round(save_rate, 1),
            "mrr_at_risk": round(stats["mrr_at_risk"], 2),
            "mrr_saved": round(stats["mrr_saved"], 2),
        })

    reason_breakdown.sort(key=lambda x: x["count"], reverse=True)

    # Competitive intelligence
    all_competitors = defaultdict(int)
    for stats in by_reason.values():
        for comp, cnt in stats["competitors_mentioned"].items():
            all_competitors[comp] += cnt

    top_competitors = sorted(all_competitors.items(), key=lambda x: x[1], reverse=True)[:5]

    # Feature gaps
    all_features = defaultdict(int)
    for stats in by_reason.values():
        for feat, cnt in stats["features_requested"].items():
            all_features[feat] += cnt

    top_features = sorted(all_features.items(), key=lambda x: x[1], reverse=True)[:5]

    # Overall metrics
    overall_save_rate = (total_saved / total_responses * 100) if total_responses > 0 else 0
    survey_completion = (total_responses / total_cancel_attempts * 100) if total_cancel_attempts > 0 else 0

    # Alerts
    alerts = _generate_alerts(reason_breakdown, overall_save_rate, survey_completion)

    return {
        "period": period,
        "summary": {
            "total_cancel_attempts": total_cancel_attempts,
            "survey_responses": total_responses,
            "survey_completion_rate_pct": round(survey_completion, 1),
            "total_saved": total_saved,
            "overall_save_rate_pct": round(overall_save_rate, 1),
            "total_mrr_at_risk": round(total_mrr_risk, 2),
            "total_mrr_saved": round(total_mrr_saved, 2),
        },
        "reason_breakdown": reason_breakdown,
        "competitive_intelligence": {
            "top_competitors": [{"name": c, "mentions": n} for c, n in top_competitors],
        },
        "feature_gaps": {
            "top_requested_features": [{"feature": f, "mentions": n} for f, n in top_features],
        },
        "alerts": alerts,
        "benchmarks": BENCHMARKS,
    }


def _generate_alerts(reasons: list, save_rate: float, completion: float) -> list:
    """Generate alerts based on analysis."""
    alerts = []

    if completion < BENCHMARKS["survey_completion_good"]:
        alerts.append({
            "severity": "HIGH",
            "type": "low_completion",
            "message": f"Survey completion rate is {completion:.1f}%. Target is {BENCHMARKS['survey_completion_good']}%+. Make the single-question survey required before showing save offers.",
        })

    if save_rate < 5:
        alerts.append({
            "severity": "CRITICAL",
            "type": "low_save_rate",
            "message": f"Overall save rate is {save_rate:.1f}%. Offers likely do not match exit reasons. Rebuild reason-to-offer mapping.",
        })
    elif save_rate < BENCHMARKS["save_rate_good"]:
        alerts.append({
            "severity": "HIGH",
            "type": "below_benchmark_save_rate",
            "message": f"Save rate {save_rate:.1f}% is below benchmark of {BENCHMARKS['save_rate_good']}%. Test stronger offers.",
        })

    for r in reasons:
        if r["percentage"] > BENCHMARKS["reason_concentration_critical"]:
            alerts.append({
                "severity": "CRITICAL",
                "type": "reason_concentration",
                "message": f"'{r['reason']}' accounts for {r['percentage']}% of cancellations. This indicates a systemic issue requiring product or leadership escalation.",
            })
        elif r["percentage"] > BENCHMARKS["reason_concentration_warning"]:
            alerts.append({
                "severity": "HIGH",
                "type": "reason_concentration",
                "message": f"'{r['reason']}' accounts for {r['percentage']}% of cancellations. Monitor trend and investigate root cause.",
            })

        if r["save_rate_pct"] < 5 and r["reason"] != "TESTING" and r["count"] >= 5:
            alerts.append({
                "severity": "HIGH",
                "type": "ineffective_offer",
                "message": f"Save rate for '{r['reason']}' is only {r['save_rate_pct']}%. The current offer for this reason is not working.",
            })

    return alerts


def format_text(result: dict) -> str:
    """Format results as human-readable text."""
    lines = []
    lines.append("=" * 60)
    lines.append(f"EXIT SURVEY ANALYZER -- Period: {result['period']}")
    lines.append("=" * 60)

    s = result["summary"]
    lines.append(f"\n--- Summary ---")
    lines.append(f"Cancel Attempts:       {s['total_cancel_attempts']:>8d}")
    lines.append(f"Survey Responses:      {s['survey_responses']:>8d}")
    lines.append(f"Survey Completion:     {s['survey_completion_rate_pct']:>8.1f}%")
    lines.append(f"Customers Saved:       {s['total_saved']:>8d}")
    lines.append(f"Overall Save Rate:     {s['overall_save_rate_pct']:>8.1f}%")
    lines.append(f"MRR at Risk:           ${s['total_mrr_at_risk']:>10,.2f}")
    lines.append(f"MRR Saved:             ${s['total_mrr_saved']:>10,.2f}")

    lines.append(f"\n--- Reason Breakdown ---")
    lines.append(f"{'Reason':<18} {'Count':>6} {'%':>6} {'Saved':>6} {'Save%':>7} {'MRR Risk':>10}")
    for r in result["reason_breakdown"]:
        lines.append(
            f"{r['reason']:<18} {r['count']:>6d} {r['percentage']:>5.1f}% "
            f"{r['saved']:>6d} {r['save_rate_pct']:>6.1f}% ${r['mrr_at_risk']:>8,.0f}"
        )

    ci = result["competitive_intelligence"]
    if ci["top_competitors"]:
        lines.append(f"\n--- Top Competitors Mentioned ---")
        for c in ci["top_competitors"]:
            lines.append(f"  {c['name']}: {c['mentions']} mentions")

    fg = result["feature_gaps"]
    if fg["top_requested_features"]:
        lines.append(f"\n--- Top Requested Features ---")
        for f in fg["top_requested_features"]:
            lines.append(f"  {f['feature']}: {f['mentions']} mentions")

    if result["alerts"]:
        lines.append(f"\n--- Alerts ---")
        for a in result["alerts"]:
            lines.append(f"[{a['severity']}] {a['message']}")

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


def main():
    parser = argparse.ArgumentParser(
        description="Analyze exit survey responses to identify churn patterns and save offer effectiveness."
    )
    parser.add_argument("input_file", help="JSON file with exit survey response data")
    parser.add_argument("--json", action="store_true", help="Output results as JSON")
    parser.add_argument("--period", default="current", help="Analysis period label (default: current)")

    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 in {args.input_file}: {e}", file=sys.stderr)
        sys.exit(1)

    result = analyze_surveys(data, args.period)

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


if __name__ == "__main__":
    main()