"""Reproduce Anivo's CRM forecast backtest with a Maven Analytics CRM ZIP."""

import argparse
import csv
import hashlib
import io
import json
from collections import Counter
from dataclasses import dataclass
from datetime import date, timedelta
from pathlib import Path
from statistics import mean
from zipfile import ZipFile


ARCHIVE_SHA256 = "f7d1a04f2651dd8c0a2d01d2e9c161438983dde01db47c3d8ba6e774012d01a1"
FIRST_ORIGIN = date(2017, 3, 6)
FIRST_TEST = date(2017, 7, 3)
LAST_TEST = date(2017, 10, 30)
FOLLOWUP_END = date(2017, 12, 31)
HORIZONS = (15, 30, 60)
AGE_LABELS = ("0–29", "30–59", "60–89", "90+")
MIN_AGE_OBSERVATIONS = 50
MODELS = ("closed_win_rate", "horizon_rate", "age_rate")


@dataclass(frozen=True)
class Deal:
    id: str
    entered: date
    closed: date | None
    won: bool


@dataclass(frozen=True)
class Observation:
    deal_id: str
    age_group: int
    won: bool


@dataclass(frozen=True)
class Prediction:
    observation: Observation
    probabilities: tuple[float, float, float]


def load_deals(archive_path):
    fingerprint = hashlib.sha256(archive_path.read_bytes()).hexdigest()
    if fingerprint != ARCHIVE_SHA256:
        raise ValueError(f"Unexpected source ZIP SHA-256: {fingerprint}")

    with ZipFile(archive_path) as archive:
        source = archive.read("sales_pipeline.csv").decode("utf-8-sig")
    rows = list(csv.DictReader(io.StringIO(source)))
    if len({row["opportunity_id"] for row in rows}) != len(rows):
        raise ValueError("Opportunity identifiers are not unique")

    deals = []
    counts = Counter()
    for row in rows:
        stage = row["deal_stage"]
        counts[stage] += 1
        if stage == "Prospecting" and not row["engage_date"] and not row["close_date"]:
            continue
        if stage not in {"Engaging", "Won", "Lost"}:
            raise ValueError(f"Unexpected row: {row['opportunity_id']}")
        entered = date.fromisoformat(row["engage_date"])
        closed = date.fromisoformat(row["close_date"]) if row["close_date"] else None
        if (stage == "Engaging") != (closed is None) or (closed and closed < entered):
            raise ValueError(f"Invalid dates: {row['opportunity_id']}")
        deals.append(Deal(row["opportunity_id"], entered, closed, stage == "Won"))

    return deals, dict(sorted(counts.items()))


def build_snapshot(deals, origin, horizon):
    deadline = origin + timedelta(days=horizon)
    if deadline > FOLLOWUP_END:
        raise ValueError("The outcome window exceeds the observation cutoff")

    return [
        Observation(
            deal.id,
            min((origin - deal.entered).days // 30, len(AGE_LABELS) - 1),
            deal.won and deal.closed <= deadline,
        )
        for deal in deals
        if deal.entered <= origin and (deal.closed is None or deal.closed > origin)
    ]


def model_summary(predictions):
    return {
        name: {
            "mean_probability": mean(item.probabilities[index] for item in predictions),
            "brier": mean(
                (item.probabilities[index] - item.observation.won) ** 2
                for item in predictions
            ),
        }
        for index, name in enumerate(MODELS)
    }


def outcome_summary(predictions):
    return {
        "rows": len(predictions),
        "opportunities": len({item.observation.deal_id for item in predictions}),
        "wins": sum(item.observation.won for item in predictions),
        "observed_rate": mean(item.observation.won for item in predictions),
        "models": model_summary(predictions),
    }


def evaluate(deals, origins, horizon):
    delay = timedelta(days=horizon)
    snapshots = {origin: build_snapshot(deals, origin, horizon) for origin in origins}
    weekly = []
    pooled = []
    first_prediction = {}

    for origin in origins:
        if origin < FIRST_TEST:
            continue

        matured = [
            row for past, snapshot in snapshots.items()
            if past + delay <= origin
            for row in snapshot
        ]
        prior_closed = [deal for deal in deals if deal.closed and deal.closed <= origin]
        closed_win_rate = mean(deal.won for deal in prior_closed)
        horizon_rate = mean(row.won for row in matured)
        age_rates = {}
        for age_group in range(len(AGE_LABELS)):
            group = [row.won for row in matured if row.age_group == age_group]
            age_rates[age_group] = mean(group) if len(group) >= MIN_AGE_OBSERVATIONS else horizon_rate

        predictions = [
            Prediction(row, (closed_win_rate, horizon_rate, age_rates[row.age_group]))
            for row in snapshots[origin]
        ]
        pooled.extend(predictions)
        for item in predictions:
            first_prediction.setdefault(item.observation.deal_id, item)

        weekly.append({
            "origin": origin.isoformat(),
            "horizon": horizon,
            "matured_rows": len(matured),
            **outcome_summary(predictions),
        })

    grouped = [
        {"age_group": label, **outcome_summary([
            item for item in pooled if item.observation.age_group == age_group
        ])}
        for age_group, label in enumerate(AGE_LABELS)
    ]
    return weekly, {
        "horizon": horizon,
        "origins": len(weekly),
        "pooled": outcome_summary(pooled),
        "first_observation": outcome_summary(list(first_prediction.values())),
        "age_groups": grouped,
        "age_improved_origins": sum(
            row["models"]["age_rate"]["brier"] < row["models"]["horizon_rate"]["brier"]
            for row in weekly
        ),
    }


def write_weekly(rows, output_path):
    columns = ["origin", "horizon", "rows", "wins", "observed_rate", "matured_rows"]
    metrics = [f"{model}_{metric}" for model in MODELS for metric in ("mean_probability", "brier")]
    with output_path.open("w", encoding="utf-8", newline="") as stream:
        writer = csv.DictWriter(stream, fieldnames=columns + metrics, lineterminator="\n")
        writer.writeheader()
        for row in rows:
            writer.writerow({
                **{key: row[key] for key in columns},
                **{f"{model}_{metric}": f"{value:.12f}"
                   for model, items in row["models"].items() for metric, value in items.items()},
            })


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("archive", type=Path, help="Original CRM Sales Opportunities ZIP")
    parser.add_argument("--out", type=Path, default=Path("."), help="Output directory")
    args = parser.parse_args()
    deals, counts = load_deals(args.archive)
    origins = [
        FIRST_ORIGIN + timedelta(days=offset)
        for offset in range(0, (LAST_TEST - FIRST_ORIGIN).days + 1, 7)
    ]

    weekly = []
    summaries = []
    for horizon in HORIZONS:
        rows, summary = evaluate(deals, origins, horizon)
        weekly.extend(rows)
        summaries.append(summary)

    args.out.mkdir(parents=True, exist_ok=True)
    write_weekly(weekly, args.out / "weekly.csv")
    result = {
        "source_zip_sha256": ARCHIVE_SHA256,
        "source_rows": sum(counts.values()),
        "observed_stage_counts": counts,
        "opportunities_with_engagement_dates": len(deals),
        "training_first_origin": FIRST_ORIGIN.isoformat(),
        "test_first_origin": FIRST_TEST.isoformat(),
        "test_last_origin": LAST_TEST.isoformat(),
        "followup_end": FOLLOWUP_END.isoformat(),
        "results": summaries,
    }
    (args.out / "results.json").write_text(
        json.dumps(result, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
    )


if __name__ == "__main__":
    main()
