"""Reproduce Anivo's decomposition of quarterly sales win rates."""

import argparse
import csv
import hashlib
import io
import json
from collections import defaultdict
from dataclasses import dataclass
from datetime import date
from fractions import Fraction
from pathlib import Path
from zipfile import ZipFile


ARCHIVE_SHA256 = "f7d1a04f2651dd8c0a2d01d2e9c161438983dde01db47c3d8ba6e774012d01a1"
QUARTERS = ("2017 Q2", "2017 Q3", "2017 Q4")
FIRST_DAY = date(2017, 4, 1)
LAST_DAY = date(2017, 12, 31)
RARE_PRODUCT = "GTK 500"


@dataclass(frozen=True)
class Deal:
    quarter: str
    won: bool
    product: str
    region: str


@dataclass
class Tally:
    closed: int = 0
    won: int = 0

    def add(self, deal):
        self.closed += 1
        self.won += deal.won

    @property
    def rate(self):
        return Fraction(self.won, self.closed)


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

    with ZipFile(path) as archive:
        pipeline = list(csv.DictReader(io.StringIO(archive.read("sales_pipeline.csv").decode("utf-8-sig"))))
        teams = list(csv.DictReader(io.StringIO(archive.read("sales_teams.csv").decode("utf-8-sig"))))

    regions = {row["sales_agent"]: row["regional_office"] for row in teams}
    if len(regions) != len(teams) or not all(regions.values()):
        raise ValueError("Invalid sales-agent region mapping")
    if len({row["opportunity_id"] for row in pipeline}) != len(pipeline):
        raise ValueError("Opportunity identifiers must be unique")

    excluded = {"open_or_prospecting": 0, "closed_outside_window": 0}
    deals = []
    for row in pipeline:
        stage = row["deal_stage"]
        if stage in {"Prospecting", "Engaging"} and not row["close_date"]:
            excluded["open_or_prospecting"] += 1
            continue
        if stage not in {"Won", "Lost"} or not row["product"]:
            raise ValueError(f"Unexpected CRM record: {row['opportunity_id']}")
        closed = date.fromisoformat(row["close_date"])
        if not FIRST_DAY <= closed <= LAST_DAY:
            excluded["closed_outside_window"] += 1
            continue
        quarter = QUARTERS[(closed.month - 4) // 3]
        deals.append(Deal(quarter, stage == "Won", row["product"], regions[row["sales_agent"]]))

    return deals, excluded


def count_by(deals, grouping):
    overall = defaultdict(Tally)
    groups = defaultdict(lambda: defaultdict(Tally))
    for deal in deals:
        overall[deal.quarter].add(deal)
        groups[deal.quarter][getattr(deal, grouping)].add(deal)
    return overall, groups


def describe(total):
    return {"closed": total.closed, "won": total.won, "lost": total.closed - total.won, "rate": float(total.rate)}


def decompose(earlier, later, totals, groups, grouping):
    a = totals[earlier]
    b = totals[later]
    if set(groups[earlier]) != set(groups[later]):
        raise ValueError(f"Some {grouping} groups are absent in one period")

    mix_total = within_total = standardized_a = standardized_b = Fraction()
    rows = []
    for group, group_a in sorted(groups[earlier].items()):
        group_b = groups[later][group]
        share_a = Fraction(group_a.closed, a.closed)
        share_b = Fraction(group_b.closed, b.closed)
        average_share = (share_a + share_b) / 2
        mix = (share_b - share_a) * (group_b.rate + group_a.rate) / 2
        within = (group_b.rate - group_a.rate) * average_share
        mix_total += mix
        within_total += within
        standardized_a += group_a.rate * average_share
        standardized_b += group_b.rate * average_share
        rows.append({
            "group": group,
            "earlier": {**describe(group_a), "share": float(share_a)},
            "later": {**describe(group_b), "share": float(share_b)},
            "mix": float(mix),
            "within": float(within),
        })

    difference = b.rate - a.rate
    volume_count = (b.closed - a.closed) * (b.rate + a.rate) / 2
    rate_count = difference * (a.closed + b.closed) / 2
    assert mix_total + within_total == difference
    assert standardized_b - standardized_a == within_total
    assert volume_count + rate_count == b.won - a.won
    return {
        "grouping": grouping,
        "earlier": earlier,
        "later": later,
        "earlier_totals": describe(a),
        "later_totals": describe(b),
        "difference": float(difference),
        "mix": float(mix_total),
        "within": float(within_total),
        "standardized_earlier": float(standardized_a),
        "standardized_later": float(standardized_b),
        "win_count_volume": float(volume_count),
        "win_count_rate": float(rate_count),
        "details": rows,
    }


def write_breakdown(results, path):
    side_fields = ("closed", "won", "lost", "rate", "share")
    columns = ["grouping", "earlier", "later", "group", "mix", "within"]
    columns += [f"{side}_{field}" for side in ("earlier", "later") for field in side_fields]
    with path.open("w", encoding="utf-8", newline="") as output:
        writer = csv.DictWriter(output, columns, lineterminator="\n")
        writer.writeheader()
        for result in results:
            for row in result["details"]:
                writer.writerow({
                    **{key: result[key] for key in ("grouping", "earlier", "later")},
                    **{key: row[key] for key in ("group", "mix", "within")},
                    **{f"{side}_{field}": row[side][field]
                       for side in ("earlier", "later") for field in side_fields},
                })


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("."))
    args = parser.parse_args()
    deals, excluded = load_deals(args.archive)
    products, by_product = count_by(deals, "product")
    regions, by_region = count_by(deals, "region")
    common = [deal for deal in deals if deal.product != RARE_PRODUCT]
    common_totals, by_common_product = count_by(common, "product")
    q2, q3, q4 = QUARTERS
    results = [
        decompose(q2, q3, products, by_product, "product"),
        decompose(q3, q4, products, by_product, "product"),
        decompose(q3, q4, regions, by_region, "region"),
        decompose(q3, q4, common_totals, by_common_product, f"product without {RARE_PRODUCT}"),
    ]

    args.out.mkdir(parents=True, exist_ok=True)
    write_breakdown(results, args.out / "breakdown.csv")
    summary = {
        "source_zip_sha256": ARCHIVE_SHA256,
        "source_rows": len(deals) + sum(excluded.values()),
        "included": len(deals),
        "excluded": excluded,
        "quarters": {quarter: describe(products[quarter]) for quarter in QUARTERS},
        "comparisons": results,
    }
    (args.out / "results.json").write_text(
        json.dumps(summary, indent=2) + "\n", encoding="utf-8"
    )


if __name__ == "__main__":
    main()
