#!/usr/bin/env python3
"""Compare quoted vs. verified component prices and write a Markdown report.

Usage:
    python3 verify.py [components.csv] [--tolerance 10] [--out report.md]

Variance is (quoted - verified) / verified. A positive value means the quote is
higher than the verified market price.
"""

import argparse
import csv
import sys
from datetime import date

REQUIRED = ["id", "component", "qty", "quoted_unit_price", "verified_unit_price"]


def parse_price(value):
    value = (value or "").strip().replace(",", "")
    return float(value) if value else None


def classify(quoted, verified, tolerance):
    if verified is None:
        return "UNVERIFIED", None
    if verified == 0:
        return ("OK" if quoted == 0 else "OVER"), None
    variance = (quoted - verified) / verified * 100
    if variance > tolerance:
        return "OVER", variance
    if variance < -tolerance:
        return "UNDER", variance
    return "OK", variance


def load_rows(path):
    with open(path, newline="", encoding="utf-8") as f:
        reader = csv.DictReader(f)
        missing = [c for c in REQUIRED if c not in (reader.fieldnames or [])]
        if missing:
            sys.exit(f"{path}: missing columns: {', '.join(missing)}")
        rows = []
        for line_no, row in enumerate(reader, start=2):
            if not any((v or "").strip() for v in row.values()):
                continue
            try:
                row["qty"] = float(row["qty"])
                row["quoted_unit_price"] = parse_price(row["quoted_unit_price"])
                row["verified_unit_price"] = parse_price(row["verified_unit_price"])
            except ValueError as e:
                sys.exit(f"{path}:{line_no}: bad number ({e})")
            if row["quoted_unit_price"] is None:
                sys.exit(f"{path}:{line_no}: quoted_unit_price is required")
            rows.append(row)
        return rows


def fmt(n):
    return "—" if n is None else f"{n:,.2f}"


def build_report(rows, tolerance, source):
    currency = next((r.get("currency") for r in rows if r.get("currency")), "")
    counts = {"OK": 0, "OVER": 0, "UNDER": 0, "UNVERIFIED": 0}
    quoted_total = 0.0
    verified_total = 0.0
    quoted_total_verified_lines = 0.0
    lines = []

    for r in rows:
        status, variance = classify(r["quoted_unit_price"], r["verified_unit_price"], tolerance)
        counts[status] += 1
        q_line = r["quoted_unit_price"] * r["qty"]
        quoted_total += q_line
        v_line = None
        if r["verified_unit_price"] is not None:
            v_line = r["verified_unit_price"] * r["qty"]
            verified_total += v_line
            quoted_total_verified_lines += q_line
        lines.append(
            f"| {r['id']} | {r['component']} | {r.get('part_number', '')} | {r['qty']:g} "
            f"| {fmt(r['quoted_unit_price'])} | {fmt(r['verified_unit_price'])} "
            f"| {fmt(q_line)} | {fmt(v_line)} "
            f"| {'—' if variance is None else f'{variance:+.1f}%'} | **{status}** "
            f"| {r.get('verified_source', '')} |"
        )

    diff = quoted_total_verified_lines - verified_total
    out = [
        "# Component Cost Verification Report",
        "",
        f"- Source: `{source}`",
        f"- Generated: {date.today().isoformat()}",
        f"- Tolerance: ±{tolerance:g}%",
        f"- Currency: {currency or 'unspecified'}",
        "",
        "## Summary",
        "",
        f"| Lines | OK | OVER | UNDER | UNVERIFIED |",
        f"|---|---|---|---|---|",
        f"| {len(rows)} | {counts['OK']} | {counts['OVER']} | {counts['UNDER']} | {counts['UNVERIFIED']} |",
        "",
        f"- Total quoted (all lines): **{fmt(quoted_total)}**",
        f"- Total quoted (verified lines only): **{fmt(quoted_total_verified_lines)}**",
        f"- Total verified: **{fmt(verified_total)}**",
        f"- Quote minus verified (verified lines only): **{diff:+,.2f}**"
        + (" (quote is higher)" if diff > 0 else " (quote is lower)" if diff < 0 else ""),
        "",
        "## Line items",
        "",
        "| ID | Component | Part # | Qty | Quoted unit | Verified unit | Quoted line | Verified line | Variance | Status | Verified source |",
        "|---|---|---|---|---|---|---|---|---|---|---|",
        *lines,
        "",
    ]
    return "\n".join(out), counts


def main():
    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    p.add_argument("csv", nargs="?", default="components.csv")
    p.add_argument("--tolerance", type=float, default=10.0, help="allowed variance in percent (default 10)")
    p.add_argument("--out", default="report.md")
    args = p.parse_args()

    rows = load_rows(args.csv)
    if not rows:
        sys.exit(f"{args.csv}: no component rows yet. Fill it in first (see PLAN.md).")
    report, counts = build_report(rows, args.tolerance, args.csv)
    with open(args.out, "w", encoding="utf-8") as f:
        f.write(report)
    print(f"Wrote {args.out}: {len(rows)} lines, "
          f"{counts['OK']} OK, {counts['OVER']} OVER, {counts['UNDER']} UNDER, "
          f"{counts['UNVERIFIED']} UNVERIFIED")
    # Exit non-zero when anything needs attention, so it can gate CI if wanted.
    return 1 if counts["OVER"] or counts["UNDER"] or counts["UNVERIFIED"] else 0


if __name__ == "__main__":
    sys.exit(main())
