Mediation Analysis

#!/usr/bin/env python3
"""
Dispute Analyzer

Analyzes dispute description text and extracts parties, claims, key issues,
timeline of events, and evidence references. Maps each party's positions
and interests. Identifies overlapping interests and potential ZOPA.

Usage:
    python dispute_analyzer.py --input dispute.txt
    python dispute_analyzer.py --text "Party A claims breach of contract..."
    python dispute_analyzer.py --input dispute.txt --json
    python dispute_analyzer.py --input dispute.txt --output analysis.json
"""

import argparse
import json
import re
import sys
from typing import Any, Dict, List, Optional, Tuple


# Entity/party extraction patterns
PARTY_INDICATORS = [
    r"(?:plaintiff|claimant|petitioner|applicant|complainant)",
    r"(?:defendant|respondent|opposing\s+party)",
    r"(?:party\s+[a-z])",
    r"(?:the\s+(?:company|employer|employee|tenant|landlord|buyer|seller|contractor|client|vendor|supplier|customer|insured|insurer|licensor|licensee))",
]

# Claim type patterns
CLAIM_PATTERNS: Dict[str, List[str]] = {
    "breach_of_contract": [
        r"\bbreach\s+of\s+contract\b", r"\bfailed\s+to\s+perform\b",
        r"\bnon-?performance\b", r"\bcontractual\s+(?:breach|violation)\b",
    ],
    "negligence": [
        r"\bnegligen(?:ce|t)\b", r"\bduty\s+of\s+care\b",
        r"\bfailed\s+to\s+exercise\b", r"\breasonable\s+care\b",
    ],
    "employment": [
        r"\bwrongful\s+(?:termination|dismissal)\b", r"\bdiscrimination\b",
        r"\bharassment\b", r"\bunfair\s+(?:dismissal|treatment)\b",
        r"\bemployment\s+(?:dispute|claim)\b",
    ],
    "intellectual_property": [
        r"\binfringement\b", r"\btrademark\b", r"\bcopyright\b",
        r"\bpatent\b", r"\btrade\s+secret\b", r"\bmisappropriation\b",
    ],
    "property": [
        r"\bland(?:lord|lady)\b", r"\btenant\b", r"\blease\b",
        r"\bproperty\s+(?:damage|dispute)\b", r"\beviction\b",
    ],
    "debt_collection": [
        r"\bowed\b", r"\bunpaid\b", r"\bdebt\b", r"\binvoice\b",
        r"\bpayment\s+(?:due|owed|outstanding)\b",
    ],
    "personal_injury": [
        r"\bpersonal\s+injury\b", r"\bbodily\s+harm\b",
        r"\bmedical\s+(?:expenses|bills)\b", r"\binjured\b",
    ],
    "professional_liability": [
        r"\bmalpractice\b", r"\bprofessional\s+(?:negligence|liability)\b",
        r"\bfiduciary\b", r"\bstandard\s+of\s+care\b",
    ],
}

# Monetary amount patterns
MONEY_PATTERN = re.compile(
    r"(?:(?:USD|EUR|GBP|CAD|AUD)\s*)?[\$\u20ac\u00a3]?\s*\d[\d,]*(?:\.\d{1,2})?\s*"
    r"(?:million|billion|thousand|[MBKmk])?(?:\s*(?:USD|EUR|GBP|CAD|AUD))?",
    re.IGNORECASE,
)

# Date patterns
DATE_PATTERN = re.compile(
    r"\b(?:\d{1,2}[/-]\d{1,2}[/-]\d{2,4}|\d{4}[/-]\d{1,2}[/-]\d{1,2}|"
    r"(?:January|February|March|April|May|June|July|August|September|October|November|December)"
    r"\s+\d{1,2},?\s+\d{4}|\d{1,2}\s+"
    r"(?:January|February|March|April|May|June|July|August|September|October|November|December)"
    r"\s+\d{4})",
    re.IGNORECASE,
)

# Evidence reference patterns
EVIDENCE_PATTERNS = [
    (r"\b(?:exhibit|evidence)\s+[A-Z\d]+\b", "formal_exhibit"),
    (r"\b(?:email|correspondence|letter)\s+(?:dated|from|of)\b", "correspondence"),
    (r"\bcontract\s+(?:dated|signed|executed)\b", "contract"),
    (r"\binvoice\s+(?:#|no\.?|number)\s*\w+", "invoice"),
    (r"\bwitness(?:es)?\b", "witness"),
    (r"\bexpert\s+(?:report|opinion|testimony)\b", "expert"),
    (r"\bphoto(?:graph)?s?\b", "photograph"),
    (r"\brecording\b", "recording"),
    (r"\bbank\s+(?:statement|record)\b", "financial_record"),
    (r"\bmedical\s+record\b", "medical_record"),
]

# Interest category patterns
INTEREST_PATTERNS: Dict[str, List[str]] = {
    "legal": [
        r"\bright\b", r"\bentitle\b", r"\bliabilit", r"\bobligat",
        r"\bprecedent\b", r"\blaw\b", r"\blegal\b",
    ],
    "commercial": [
        r"\bbusiness\b", r"\brevenue\b", r"\bprofit\b", r"\bcost\b",
        r"\bmarket\b", r"\breputation\b", r"\bfinancial\b",
    ],
    "relational": [
        r"\brelationship\b", r"\bpartnership\b", r"\bongoing\b",
        r"\bfuture\s+(?:business|dealings)\b", r"\btrust\b",
    ],
    "emotional": [
        r"\bfairness\b", r"\brespect\b", r"\backnowledg", r"\bapolog",
        r"\bfrustr", r"\banger\b", r"\bdisappoint\b", r"\bprincipl",
    ],
    "procedural": [
        r"\bspeed\b", r"\bquick\b", r"\bprivac(?:y|ate)\b",
        r"\bconfidential\b", r"\bcontrol\b", r"\bvoice\b",
    ],
}


def extract_sentences(text: str) -> List[str]:
    """Split into sentences."""
    abbrevs = ["Mr.", "Mrs.", "Ms.", "Dr.", "Jr.", "Sr.", "No.", "Art.", "Sec.", "v."]
    protected = text
    for abbr in abbrevs:
        protected = protected.replace(abbr, abbr.replace(".", "<DOT>"))
    sentences = re.split(r'(?<=[.!?])\s+', protected)
    return [s.replace("<DOT>", ".").strip() for s in sentences if s.strip()]


def extract_parties(text: str) -> List[Dict[str, Any]]:
    """Extract party references from text."""
    parties = []
    seen_labels = set()
    text_lower = text.lower()

    # Named parties: "X v Y" or "X vs Y" or "X versus Y"
    vs_match = re.search(r'([A-Z][\w\s&,.]+?)\s+(?:v\.?|vs\.?|versus)\s+([A-Z][\w\s&,.]+?)(?:\.|,|\s{2})', text)
    if vs_match:
        for i, group in enumerate([vs_match.group(1).strip(), vs_match.group(2).strip()], 1):
            label = f"Party {i}"
            parties.append({"name": group, "label": label, "role": "claimant" if i == 1 else "respondent"})
            seen_labels.add(label)

    # Role-based extraction
    for pat in PARTY_INDICATORS:
        for m in re.finditer(pat, text_lower):
            matched = m.group().strip()
            if matched not in seen_labels:
                seen_labels.add(matched)
                role = "claimant" if any(w in matched for w in ["plaintiff", "claimant", "petitioner", "applicant"]) else "respondent"
                parties.append({"name": matched.title(), "label": matched.title(), "role": role})

    if not parties:
        parties = [
            {"name": "Party A", "label": "Party A", "role": "claimant"},
            {"name": "Party B", "label": "Party B", "role": "respondent"},
        ]
    return parties


def extract_claims(text: str) -> List[Dict[str, Any]]:
    """Extract and classify claims from text."""
    claims = []
    text_lower = text.lower()
    sentences = extract_sentences(text)

    for claim_type, patterns in CLAIM_PATTERNS.items():
        for pat in patterns:
            for m in re.finditer(pat, text_lower):
                # Find the sentence containing this match
                for sent in sentences:
                    if m.group() in sent.lower():
                        claims.append({
                            "type": claim_type,
                            "matched_phrase": m.group(),
                            "context": sent.strip()[:200],
                        })
                        break
                break  # One match per pattern group is enough

    # Deduplicate by type
    seen_types = set()
    unique = []
    for c in claims:
        if c["type"] not in seen_types:
            seen_types.add(c["type"])
            unique.append(c)
    return unique


def extract_monetary_amounts(text: str) -> List[Dict[str, str]]:
    """Extract monetary amounts from text."""
    amounts = []
    sentences = extract_sentences(text)
    for sent in sentences:
        for m in MONEY_PATTERN.finditer(sent):
            val = m.group().strip()
            if val and any(c.isdigit() for c in val) and len(val) > 1:
                amounts.append({
                    "amount": val,
                    "context": sent.strip()[:200],
                })
    return amounts


def extract_dates(text: str) -> List[Dict[str, str]]:
    """Extract dates and build timeline."""
    dates = []
    sentences = extract_sentences(text)
    for sent in sentences:
        for m in DATE_PATTERN.finditer(sent):
            dates.append({
                "date": m.group().strip(),
                "context": sent.strip()[:200],
            })
    return dates


def extract_evidence(text: str) -> List[Dict[str, str]]:
    """Extract evidence references."""
    evidence = []
    sentences = extract_sentences(text)
    for sent in sentences:
        for pat, etype in EVIDENCE_PATTERNS:
            for m in re.finditer(pat, sent, re.IGNORECASE):
                evidence.append({
                    "type": etype,
                    "reference": m.group().strip(),
                    "context": sent.strip()[:200],
                })
    return evidence


def analyze_interests(text: str) -> Dict[str, List[str]]:
    """Identify interest categories present in the text."""
    text_lower = text.lower()
    found: Dict[str, List[str]] = {}
    for category, patterns in INTEREST_PATTERNS.items():
        matches = []
        for pat in patterns:
            for m in re.finditer(pat, text_lower):
                matches.append(m.group())
        if matches:
            found[category] = list(set(matches))
    return found


def assess_complexity(
    parties: List, claims: List, amounts: List, dates: List, evidence: List, text: str
) -> Dict[str, Any]:
    """Assess dispute complexity."""
    word_count = len(text.split())
    factors = {
        "party_count": len(parties),
        "claim_count": len(claims),
        "monetary_references": len(amounts),
        "date_references": len(dates),
        "evidence_references": len(evidence),
        "text_length_words": word_count,
    }
    score = 0
    score += min(len(parties), 4)
    score += min(len(claims) * 2, 8)
    score += min(len(amounts), 3)
    score += min(len(evidence), 3)
    score += 2 if word_count > 2000 else (1 if word_count > 500 else 0)

    if score >= 12:
        level = "high"
    elif score >= 6:
        level = "moderate"
    else:
        level = "low"

    factors["complexity_score"] = score
    factors["complexity_level"] = level
    return factors


def format_human_report(analysis: Dict[str, Any]) -> str:
    """Format analysis as human-readable report."""
    lines = []
    lines.append("=" * 72)
    lines.append("DISPUTE ANALYSIS REPORT")
    lines.append("=" * 72)

    lines.append(f"\nComplexity: {analysis['complexity']['complexity_level'].upper()} "
                 f"(score: {analysis['complexity']['complexity_score']})")

    lines.append("\n--- PARTIES ---")
    for p in analysis["parties"]:
        lines.append(f"  {p['name']} ({p['role']})")

    lines.append(f"\n--- CLAIMS ({len(analysis['claims'])}) ---")
    for c in analysis["claims"]:
        lines.append(f"  Type: {c['type'].replace('_', ' ').title()}")
        lines.append(f"    {c['context'][:150]}")

    if analysis["monetary_amounts"]:
        lines.append(f"\n--- MONETARY AMOUNTS ({len(analysis['monetary_amounts'])}) ---")
        for a in analysis["monetary_amounts"]:
            lines.append(f"  {a['amount']}")
            lines.append(f"    {a['context'][:150]}")

    if analysis["timeline"]:
        lines.append(f"\n--- TIMELINE ({len(analysis['timeline'])}) ---")
        for d in analysis["timeline"]:
            lines.append(f"  {d['date']}: {d['context'][:120]}")

    if analysis["evidence"]:
        lines.append(f"\n--- EVIDENCE REFERENCES ({len(analysis['evidence'])}) ---")
        for e in analysis["evidence"]:
            lines.append(f"  [{e['type']}] {e['reference']}")

    if analysis["interests"]:
        lines.append("\n--- INTEREST CATEGORIES ---")
        for cat, keywords in analysis["interests"].items():
            lines.append(f"  {cat.title()}: {', '.join(keywords)}")

    lines.append("\n--- ZOPA INDICATORS ---")
    if analysis["interests"].get("relational"):
        lines.append("  + Relational interests present -- parties may value ongoing relationship")
    if analysis["interests"].get("procedural"):
        lines.append("  + Procedural interests present -- process matters to parties")
    if analysis["interests"].get("emotional"):
        lines.append("  + Emotional interests present -- consider non-monetary resolution elements")
    shared = set()
    for cat in analysis["interests"]:
        if cat in ("relational", "procedural"):
            shared.add(cat)
    if shared:
        lines.append(f"  Potentially shared interests: {', '.join(shared)}")

    lines.append("\n" + "=" * 72)
    return "\n".join(lines)


def main() -> None:
    parser = argparse.ArgumentParser(
        description="Analyze dispute description and extract structured dispute data."
    )
    parser.add_argument("--input", "-i", type=str, help="Path to dispute description file")
    parser.add_argument("--text", "-t", type=str, help="Inline dispute text")
    parser.add_argument("--output", "-o", type=str, help="Path to save output (JSON)")
    parser.add_argument("--json", action="store_true", help="Output in JSON format")
    args = parser.parse_args()

    if not args.input and not args.text:
        parser.print_help()
        sys.exit(1)

    try:
        if args.input:
            with open(args.input, "r", encoding="utf-8") as f:
                text = f.read()
        else:
            text = args.text

        if not text or not text.strip():
            print("Error: Empty input text.", file=sys.stderr)
            sys.exit(1)

        parties = extract_parties(text)
        claims = extract_claims(text)
        amounts = extract_monetary_amounts(text)
        dates = extract_dates(text)
        evidence = extract_evidence(text)
        interests = analyze_interests(text)
        complexity = assess_complexity(parties, claims, amounts, dates, evidence, text)

        analysis = {
            "parties": parties,
            "claims": claims,
            "monetary_amounts": amounts,
            "timeline": dates,
            "evidence": evidence,
            "interests": interests,
            "complexity": complexity,
        }

        if args.output:
            with open(args.output, "w", encoding="utf-8") as f:
                json.dump(analysis, f, indent=2, ensure_ascii=False)
            print(f"Analysis saved to {args.output}")
        elif args.json:
            print(json.dumps(analysis, indent=2, ensure_ascii=False))
        else:
            print(format_human_report(analysis))

    except FileNotFoundError:
        print(f"Error: File not found: {args.input}", file=sys.stderr)
        sys.exit(1)
    except Exception as e:
        print(f"Error: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Settlement Calculator

Takes dispute parameters and calculates BATNA/WATNA for each party, ZOPA range,
and three settlement scenarios (conservative, balanced, creative). Supports
both inline parameters and JSON input.

Usage:
    python settlement_calculator.py --input params.json
    python settlement_calculator.py --input params.json --json
    python settlement_calculator.py --claimed 500000 --litigation-cost-a 80000 \
        --litigation-cost-b 120000 --probability 0.65 --time-to-trial 18
    python settlement_calculator.py --input params.json --output settlement.json

Input JSON schema:
{
    "claimed_amount": 500000,
    "litigation_cost_a": 80000,
    "litigation_cost_b": 120000,
    "success_probability": 0.65,
    "time_to_trial_months": 18,
    "discount_rate_annual": 0.05,
    "partial_recovery_low": 0.3,
    "partial_recovery_high": 0.8,
    "non_monetary_factors": ["ongoing relationship", "confidentiality"],
    "counterclaim_amount": 0,
    "counterclaim_probability": 0.0,
    "party_a_name": "Claimant",
    "party_b_name": "Respondent"
}
"""

import argparse
import json
import math
import sys
from typing import Any, Dict, List, Optional, Tuple


DEFAULT_PARAMS = {
    "claimed_amount": 0,
    "litigation_cost_a": 0,
    "litigation_cost_b": 0,
    "success_probability": 0.5,
    "time_to_trial_months": 12,
    "discount_rate_annual": 0.05,
    "partial_recovery_low": 0.3,
    "partial_recovery_high": 0.8,
    "non_monetary_factors": [],
    "counterclaim_amount": 0,
    "counterclaim_probability": 0.0,
    "party_a_name": "Party A (Claimant)",
    "party_b_name": "Party B (Respondent)",
}


def present_value(amount: float, months: int, annual_rate: float) -> float:
    """Calculate present value of a future amount."""
    if annual_rate <= 0 or months <= 0:
        return amount
    years = months / 12.0
    return amount / ((1 + annual_rate) ** years)


def calculate_batna_watna(params: Dict[str, Any]) -> Dict[str, Any]:
    """Calculate BATNA and WATNA for both parties."""
    claimed = params["claimed_amount"]
    cost_a = params["litigation_cost_a"]
    cost_b = params["litigation_cost_b"]
    prob = params["success_probability"]
    months = params["time_to_trial_months"]
    rate = params["discount_rate_annual"]
    low_pct = params["partial_recovery_low"]
    high_pct = params["partial_recovery_high"]
    counterclaim = params.get("counterclaim_amount", 0)
    counter_prob = params.get("counterclaim_probability", 0)

    # Party A (Claimant) analysis
    a_best_case = claimed - cost_a  # Win full amount minus own costs
    a_worst_case = -cost_a - (counterclaim * counter_prob)  # Lose, pay costs, face counterclaim
    a_expected_value = (prob * claimed * (low_pct + high_pct) / 2) - cost_a
    a_expected_pv = present_value(a_expected_value, months, rate)

    # Risk-adjusted expected value
    a_risk_adjusted = (prob * claimed) - cost_a - (counter_prob * counterclaim)

    # Party B (Respondent) analysis
    b_best_case = -cost_b  # Win case, only pay own costs
    b_worst_case = -(claimed + cost_b)  # Lose full amount plus costs
    b_expected_value = -(prob * claimed * (low_pct + high_pct) / 2) - cost_b
    b_expected_pv = present_value(abs(b_expected_value), months, rate) * -1

    # Risk-adjusted for respondent
    b_risk_adjusted = -(prob * claimed) - cost_b + (counter_prob * counterclaim)

    return {
        "party_a": {
            "name": params["party_a_name"],
            "best_case_trial": round(a_best_case, 2),
            "worst_case_trial": round(a_worst_case, 2),
            "expected_value": round(a_expected_value, 2),
            "present_value": round(a_expected_pv, 2),
            "risk_adjusted": round(a_risk_adjusted, 2),
            "litigation_cost": cost_a,
        },
        "party_b": {
            "name": params["party_b_name"],
            "best_case_trial": round(b_best_case, 2),
            "worst_case_trial": round(b_worst_case, 2),
            "expected_value": round(b_expected_value, 2),
            "present_value": round(b_expected_pv, 2),
            "risk_adjusted": round(b_risk_adjusted, 2),
            "litigation_cost": cost_b,
        },
    }


def calculate_zopa(params: Dict[str, Any], batna: Dict[str, Any]) -> Dict[str, Any]:
    """Calculate Zone of Possible Agreement."""
    claimed = params["claimed_amount"]
    prob = params["success_probability"]
    cost_a = params["litigation_cost_a"]
    cost_b = params["litigation_cost_b"]

    # Party A's minimum acceptable: what they'd get at trial minus costs and risk
    a_minimum = max(0, (prob * claimed) - cost_a)

    # Party B's maximum acceptable: what they'd lose at trial plus costs avoided
    b_maximum = (prob * claimed) + cost_b

    zopa_exists = a_minimum < b_maximum
    zopa_range = round(b_maximum - a_minimum, 2) if zopa_exists else 0
    midpoint = round((a_minimum + b_maximum) / 2, 2) if zopa_exists else 0

    return {
        "exists": zopa_exists,
        "party_a_minimum": round(a_minimum, 2),
        "party_b_maximum": round(b_maximum, 2),
        "range": zopa_range,
        "midpoint": midpoint,
        "as_percentage_of_claim": round(midpoint / claimed * 100, 1) if claimed > 0 else 0,
    }


def generate_scenarios(
    params: Dict[str, Any], batna: Dict[str, Any], zopa: Dict[str, Any]
) -> List[Dict[str, Any]]:
    """Generate three settlement scenarios."""
    claimed = params["claimed_amount"]
    non_monetary = params.get("non_monetary_factors", [])

    scenarios = []

    # Scenario 1: Straightforward Compromise (split-the-difference within ZOPA)
    if zopa["exists"]:
        compromise_amount = zopa["midpoint"]
    else:
        # If no ZOPA, use risk-adjusted midpoint
        compromise_amount = round(claimed * params["success_probability"] * 0.75, 2)

    scenarios.append({
        "name": "Straightforward Compromise",
        "settlement_amount": round(compromise_amount, 2),
        "percentage_of_claim": round(compromise_amount / claimed * 100, 1) if claimed > 0 else 0,
        "rationale": (
            "Pure monetary split based on litigation risk analysis. "
            "Amount reflects the expected value of litigation discounted by costs and uncertainty."
        ),
        "terms": [
            f"Lump sum payment of {compromise_amount:,.2f}",
            "Full and final settlement",
            "Mutual release of all claims",
            "Each party bears own costs",
        ],
        "suitable_when": "Simple monetary dispute with no ongoing relationship",
    })

    # Scenario 2: Interest-Based Solution
    interest_amount = round(compromise_amount * 0.85, 2)  # Slightly less cash
    interest_terms = [
        f"Monetary component: {interest_amount:,.2f}",
        "Mutual release with non-disparagement clause",
        "Confidentiality of settlement terms",
    ]
    if "ongoing relationship" in [f.lower() for f in non_monetary]:
        interest_terms.append("Framework for future business dealings")
    if "confidentiality" in [f.lower() for f in non_monetary]:
        interest_terms.append("Enhanced confidentiality provisions")
    if non_monetary:
        interest_terms.append(f"Non-monetary elements: {', '.join(non_monetary)}")

    scenarios.append({
        "name": "Interest-Based Solution",
        "settlement_amount": interest_amount,
        "percentage_of_claim": round(interest_amount / claimed * 100, 1) if claimed > 0 else 0,
        "rationale": (
            "Lower monetary amount offset by non-monetary value. "
            "Addresses underlying interests beyond pure financial recovery."
        ),
        "terms": interest_terms,
        "suitable_when": "Parties have ongoing relationship or value non-monetary outcomes",
    })

    # Scenario 3: Package Deal (phased payment + non-monetary)
    total_package = round(compromise_amount * 1.05, 2)  # Slightly more total value
    initial_payment = round(total_package * 0.5, 2)
    deferred_payment = round(total_package * 0.5, 2)

    package_terms = [
        f"Initial payment: {initial_payment:,.2f} within 30 days",
        f"Deferred payment: {deferred_payment:,.2f} over 6-12 months",
        f"Total package value: {total_package:,.2f}",
        "Mutual release upon completion of all payments",
        "Performance guarantee / security for deferred payments",
    ]
    if non_monetary:
        package_terms.append(f"Non-monetary elements: {', '.join(non_monetary)}")

    scenarios.append({
        "name": "Package Deal",
        "settlement_amount": total_package,
        "percentage_of_claim": round(total_package / claimed * 100, 1) if claimed > 0 else 0,
        "rationale": (
            "Higher total value delivered through phased payments, reducing immediate "
            "cash burden on paying party while providing certainty to receiving party. "
            "Bundles monetary and non-monetary elements."
        ),
        "terms": package_terms,
        "suitable_when": "Paying party has cash flow constraints; multiple issues to trade off",
    })

    return scenarios


def build_sensitivity(params: Dict[str, Any]) -> List[Dict[str, Any]]:
    """Run sensitivity analysis across probability ranges."""
    claimed = params["claimed_amount"]
    cost_a = params["litigation_cost_a"]
    cost_b = params["litigation_cost_b"]
    results = []
    for prob in [0.2, 0.35, 0.5, 0.65, 0.8]:
        a_min = max(0, (prob * claimed) - cost_a)
        b_max = (prob * claimed) + cost_b
        mid = round((a_min + b_max) / 2, 2)
        results.append({
            "probability": prob,
            "party_a_minimum": round(a_min, 2),
            "party_b_maximum": round(b_max, 2),
            "midpoint": mid,
            "zopa_exists": a_min < b_max,
        })
    return results


def format_currency(amount: float) -> str:
    """Format number as currency string."""
    if amount < 0:
        return f"-{abs(amount):,.2f}"
    return f"{amount:,.2f}"


def format_human_report(result: Dict[str, Any]) -> str:
    """Format results as human-readable report."""
    lines = []
    lines.append("=" * 72)
    lines.append("SETTLEMENT ANALYSIS REPORT")
    lines.append("=" * 72)

    p = result["parameters"]
    lines.append(f"\nClaimed amount:        {format_currency(p['claimed_amount'])}")
    lines.append(f"Success probability:   {p['success_probability']:.0%}")
    lines.append(f"Time to trial:         {p['time_to_trial_months']} months")
    lines.append(f"Litigation cost (A):   {format_currency(p['litigation_cost_a'])}")
    lines.append(f"Litigation cost (B):   {format_currency(p['litigation_cost_b'])}")

    b = result["batna_watna"]
    lines.append(f"\n--- {b['party_a']['name'].upper()} ---")
    lines.append(f"  Best case at trial:   {format_currency(b['party_a']['best_case_trial'])}")
    lines.append(f"  Worst case at trial:  {format_currency(b['party_a']['worst_case_trial'])}")
    lines.append(f"  Expected value:       {format_currency(b['party_a']['expected_value'])}")
    lines.append(f"  Risk-adjusted:        {format_currency(b['party_a']['risk_adjusted'])}")

    lines.append(f"\n--- {b['party_b']['name'].upper()} ---")
    lines.append(f"  Best case at trial:   {format_currency(b['party_b']['best_case_trial'])}")
    lines.append(f"  Worst case at trial:  {format_currency(b['party_b']['worst_case_trial'])}")
    lines.append(f"  Expected value:       {format_currency(b['party_b']['expected_value'])}")
    lines.append(f"  Risk-adjusted:        {format_currency(b['party_b']['risk_adjusted'])}")

    z = result["zopa"]
    lines.append(f"\n--- ZOPA ---")
    lines.append(f"  ZOPA exists:          {'YES' if z['exists'] else 'NO'}")
    if z["exists"]:
        lines.append(f"  A minimum:            {format_currency(z['party_a_minimum'])}")
        lines.append(f"  B maximum:            {format_currency(z['party_b_maximum'])}")
        lines.append(f"  Range:                {format_currency(z['range'])}")
        lines.append(f"  Midpoint:             {format_currency(z['midpoint'])} ({z['as_percentage_of_claim']}% of claim)")

    lines.append("\n--- SETTLEMENT SCENARIOS ---")
    for i, s in enumerate(result["scenarios"], 1):
        lines.append(f"\n  Scenario {i}: {s['name']}")
        lines.append(f"    Amount:    {format_currency(s['settlement_amount'])} ({s['percentage_of_claim']}% of claim)")
        lines.append(f"    Rationale: {s['rationale'][:150]}")
        lines.append(f"    Suitable:  {s['suitable_when']}")
        lines.append(f"    Terms:")
        for t in s["terms"]:
            lines.append(f"      - {t}")

    lines.append("\n--- SENSITIVITY ANALYSIS ---")
    lines.append(f"  {'Prob':>6s}  {'A Min':>12s}  {'B Max':>12s}  {'Midpoint':>12s}  ZOPA")
    for sa in result["sensitivity"]:
        lines.append(
            f"  {sa['probability']:>5.0%}  {format_currency(sa['party_a_minimum']):>12s}  "
            f"{format_currency(sa['party_b_maximum']):>12s}  "
            f"{format_currency(sa['midpoint']):>12s}  {'Yes' if sa['zopa_exists'] else 'No'}"
        )

    lines.append("\n" + "=" * 72)
    return "\n".join(lines)


def main() -> None:
    parser = argparse.ArgumentParser(
        description="Calculate settlement ranges, BATNA/WATNA, ZOPA, and scenarios."
    )
    parser.add_argument("--input", "-i", type=str, help="Path to parameters JSON file")
    parser.add_argument("--claimed", type=float, help="Claimed amount")
    parser.add_argument("--litigation-cost-a", type=float, help="Party A litigation costs")
    parser.add_argument("--litigation-cost-b", type=float, help="Party B litigation costs")
    parser.add_argument("--probability", type=float, help="Success probability (0-1)")
    parser.add_argument("--time-to-trial", type=int, help="Months to trial")
    parser.add_argument("--output", "-o", type=str, help="Path to save output (JSON)")
    parser.add_argument("--json", action="store_true", help="Output in JSON format")
    args = parser.parse_args()

    try:
        params = dict(DEFAULT_PARAMS)

        if args.input:
            with open(args.input, "r", encoding="utf-8") as f:
                file_params = json.load(f)
            params.update(file_params)
        elif args.claimed is not None:
            params["claimed_amount"] = args.claimed
            if args.litigation_cost_a is not None:
                params["litigation_cost_a"] = args.litigation_cost_a
            if args.litigation_cost_b is not None:
                params["litigation_cost_b"] = args.litigation_cost_b
            if args.probability is not None:
                params["success_probability"] = args.probability
            if args.time_to_trial is not None:
                params["time_to_trial_months"] = args.time_to_trial
        else:
            parser.print_help()
            sys.exit(1)

        if params["claimed_amount"] <= 0:
            print("Error: Claimed amount must be positive.", file=sys.stderr)
            sys.exit(1)
        if not (0 <= params["success_probability"] <= 1):
            print("Error: Probability must be between 0 and 1.", file=sys.stderr)
            sys.exit(1)

        batna = calculate_batna_watna(params)
        zopa = calculate_zopa(params, batna)
        scenarios = generate_scenarios(params, batna, zopa)
        sensitivity = build_sensitivity(params)

        result = {
            "parameters": params,
            "batna_watna": batna,
            "zopa": zopa,
            "scenarios": scenarios,
            "sensitivity": sensitivity,
        }

        if args.output:
            with open(args.output, "w", encoding="utf-8") as f:
                json.dump(result, f, indent=2, ensure_ascii=False)
            print(f"Settlement analysis saved to {args.output}")
        elif args.json:
            print(json.dumps(result, indent=2, ensure_ascii=False))
        else:
            print(format_human_report(result))

    except FileNotFoundError:
        print(f"Error: File not found: {args.input}", file=sys.stderr)
        sys.exit(1)
    except json.JSONDecodeError as e:
        print(f"Error: Invalid JSON in input file: {e}", file=sys.stderr)
        sys.exit(1)
    except Exception as e:
        print(f"Error: {e}", file=sys.stderr)
        sys.exit(1)


if __name__ == "__main__":
    main()