#!/usr/bin/env python3
"""
build_data.py — generates data.js from source CSVs.
Run: python3 build_data.py
Output: data.js (loaded by dashboard.html via <script src="data.js">)

Sources:
  - data/CSU utility bills/Usagedata_Jun 2025 to Jun 2026.csv                        → monthlyData
  - data/CSU utility bills/CSU 15-min data/combined_clean.csv         → csuRaw
  - data/ChargeLab Exports/report-*.csv     → sessions + realIntervalKwh (15-min dashboard exports, preferred)
  - data/ChargeLab Exports/chargelab_transactions_*.csv → sessions (API pull, fallback if no report-*.csv)
"""

import csv, json, os, glob
from datetime import datetime
from collections import defaultdict

BASE = os.path.dirname(os.path.abspath(__file__))


def dict_rows(path):
    """csv.DictReader that tolerates stray leading blank lines before the header
    (seen in at least one ChargeLab export).

    Reads via binary + explicit decode rather than text-mode readlines() —
    text-mode reads of large files have been observed to intermittently
    return 0 lines in this environment despite the file being intact on disk.
    Raises loudly if a non-empty file still parses to 0 rows, rather than
    silently proceeding with wrong (too-low) totals.
    """
    with open(path, 'rb') as f:
        text = f.read().decode('utf-8')
    lines = text.splitlines(keepends=True)
    start = next((i for i, l in enumerate(lines) if l.strip()), 0)
    rows = list(csv.DictReader(lines[start:]))
    if not rows and os.path.getsize(path) > 0:
        raise RuntimeError(
            f"{path} parsed to 0 rows but is {os.path.getsize(path)} bytes on disk — "
            f"read likely failed, file is not actually empty")
    return rows

# ─── MONTHLY DATA ─────────────────────────────────────────────────────────────
# Hardcoded from PDF bills — not derivable from CSVs automatically.
# Update manually when new bills arrive.

monthly_data = [
    # electricCost = electric-only charge from PDF bills (billing periods matched chronologically)
    # demandOn = kW/On charge | demandOff = kW/XOF + minimum charge | demandTotal = sum
    # billKwh = kWh from the actual invoice (matched billing period — used for blended $/kWh)
    # demandOnKw  = on-peak kW billed (back-calculated: demandOn $ ÷ rate ÷ days)
    # demandXofKw = excess off-peak kW billed (kW/XOF charge ÷ rate ÷ days); 0 when off-peak ≤ on-peak
    {"month":"Jun 2025","kwh":21230.28,"demand":50.0,  "bill":9054.78,  "electricCost":2938.47,"demandOn":1268.85,"demandOff": 675.92,"demandTotal":1944.77,"billKwh":20165,"demandOnKw": 50.0,"demandXofKw": 0.0},
    {"month":"Jul 2025","kwh":20000.83,"demand":41.4,  "bill":9439.25,  "electricCost":2910.62,"demandOn":1187.90,"demandOff": 778.56,"demandTotal":1966.46,"billKwh":19700,"demandOnKw": 45.3,"demandXofKw": 4.8},
    {"month":"Aug 2025","kwh":19803.69,"demand":42.3,  "bill":10662.26, "electricCost":2790.90,"demandOn":1073.45,"demandOff": 802.93,"demandTotal":1876.38,"billKwh":19070,"demandOnKw": 42.3,"demandXofKw": 4.6},
    {"month":"Sep 2025","kwh":18168.29,"demand":38.6,  "bill":9678.67,  "electricCost":2796.74,"demandOn":1136.89,"demandOff": 761.69,"demandTotal":1898.58,"billKwh":18251,"demandOnKw": 44.8,"demandXofKw": 0.0},
    {"month":"Oct 2025","kwh":30660.08,"demand":93.0,  "bill":8841.46,  "electricCost":4363.00,"demandOn":2438.73,"demandOff": 161.92,"demandTotal":2600.65,"billKwh":41158,"demandOnKw": 93.0,"demandXofKw": 9.5},
    {"month":"Nov 2025","kwh":54730.29,"demand":101.2, "bill":9560.84,  "electricCost":5718.97,"demandOn":3118.83,"demandOff": 164.94,"demandTotal":3283.77,"billKwh":59046,"demandOnKw":122.9,"demandXofKw":10.0},
    {"month":"Dec 2025","kwh":64171.76,"demand":122.9, "bill":10773.27, "electricCost":5425.37,"demandOn":2889.54,"demandOff": 110.77,"demandTotal":3000.31,"billKwh":59672,"demandOnKw":111.8,"demandXofKw": 6.6},
    {"month":"Jan 2026","kwh":71203.41,"demand":140.6, "bill":10250.86, "electricCost":6953.40,"demandOn":3902.69,"demandOff":  97.43,"demandTotal":4000.12,"billKwh":72276,"demandOnKw":140.6,"demandXofKw": 5.4},
    {"month":"Feb 2026","kwh":57379.80,"demand":117.1, "bill":13126.87, "electricCost":5543.68,"demandOn":3013.92,"demandOff":  61.11,"demandTotal":3075.03,"billKwh":59875,"demandOnKw":112.2,"demandXofKw": 3.5},
    {"month":"Mar 2026","kwh":56161.48,"demand":106.8, "bill":11256.52, "electricCost":5176.90,"demandOn":2906.47,"demandOff": 134.44,"demandTotal":3040.91,"billKwh":51909,"demandOnKw":108.2,"demandXofKw": 7.7},
    {"month":"Apr 2026","kwh":46317.14,"demand":85.1,  "bill":10884.64, "electricCost":4482.44,"demandOn":2464.86,"demandOff": 189.08,"demandTotal":2653.94,"billKwh":46692,"demandOnKw": 88.8,"demandXofKw": 3.5},
    {"month":"May 2026","kwh":39218.16,"demand":88.8,  "bill":10697.14, "electricCost":3703.34,"demandOn":2069.54,"demandOff": 330.47,"demandTotal":2400.01,"billKwh":30964,"demandOnKw": 79.7,"demandXofKw": 6.2},
]

# ─── CSU 15-MIN INTERVALS ─────────────────────────────────────────────────────

def load_csu(path):
    """Load the deduped/corrected CSU 15-min series produced by csu_data_check.py.
    Format: header row Timestamp, Day, Time, Consumption (kWh), kVARh, Account, Meter, SourceFile.
    Returns list of ['YYYY-MM-DDTHH:MM', kWh].
    """
    rows = []
    with open(path) as f:
        for row in csv.DictReader(f):
            ts = row['Timestamp'][:16]  # 2026-06-08T00:15:00 -> 2026-06-08T00:15
            rows.append([ts, float(row['Consumption (kWh)'])])
    return rows

csu_path = os.path.join(
    BASE, "data/CSU utility bills/CSU 15-min data/combined_clean.csv")
try:
    csu_raw = load_csu(csu_path)
    print(f"CSU: {len(csu_raw)} intervals loaded from {os.path.basename(csu_path)}")
except Exception as e:
    print(f"WARNING: Could not load CSU data: {e}")
    csu_raw = []

# ─── CHARGELAB SESSIONS + 15-MIN INTERVALS ────────────────────────────────────
# report-*.csv (ChargeLab dashboard export) carries both session-level fields
# (Session ID/start/end/energy) and 15-min interval fields in the same rows, and
# is refreshed more often/comprehensively than the transactions API pull — so it
# is the preferred source for both. Fall back to chargelab_transactions_*.csv
# (sessions only, no interval breakdown) if no report file is present.

cl_exports_dir = os.path.join(BASE, "data/ChargeLab Exports")
report_csvs = sorted(glob.glob(os.path.join(cl_exports_dir, "report-*.csv")))
api_csvs = sorted(glob.glob(os.path.join(cl_exports_dir, "chargelab_transactions_*.csv")))

sessions_map = {}
interval_buckets = defaultdict(lambda: defaultdict(float))  # charger → bucket_key → kW

if report_csvs:
    seen_intervals = set()
    for cl_path in report_csvs:
        for row in dict_rows(cl_path):
            charger = row['Charger display ID']
            sid = row['Session ID']
            if sid not in sessions_map:
                start = row['Session start date/time (YYYY-MM-DD hh:mm:ss) (local)'][:16].replace(' ', 'T')
                end   = row['Session end date/time (YYYY-MM-DD hh:mm:ss) (local)'][:16].replace(' ', 'T')
                try:
                    kwh = float(row['Session energy provided (kWh)'])
                except ValueError:
                    kwh = 0.0
                try:
                    # Repeated identically on every interval row for a session
                    # (verified), so safe to take from the first row seen.
                    payment = float(row['Payment collected ($)'])
                except (ValueError, KeyError):
                    payment = 0.0
                sessions_map[sid] = {'charger': charger, 'start': start, 'end': end, 'kwh': kwh, 'payment': payment}

            kw = float(row['Rolling 15-minute average power (kW)'])
            if kw == 0:
                continue
            ts_str = row['Interval start date/time (YYYY-MM-DD hh:mm:ss) (local)']
            iv_id  = row.get('15-minute interval ID', ts_str + charger)
            if iv_id in seen_intervals:
                continue
            seen_intervals.add(iv_id)
            dt = datetime.strptime(ts_str, '%Y-%m-%d %H:%M:%S')
            bucket_min = (dt.minute // 15) * 15
            bucket = dt.replace(minute=bucket_min, second=0, microsecond=0)
            key = bucket.strftime('%Y-%m-%dT%H:%M')
            if kw > interval_buckets[charger][key]:
                interval_buckets[charger][key] = kw
    sessions = sorted(sessions_map.values(), key=lambda s: s['start'])
    print(f"ChargeLab sessions: {len(sessions)} loaded from report file(s): {[os.path.basename(p) for p in report_csvs]}")
    print(f"ChargeLab intervals: {sum(len(v) for v in interval_buckets.values())} buckets from {len(report_csvs)} report file(s)")
elif api_csvs:
    cl_api_path = api_csvs[-1]  # latest by filename (date-stamped)
    with open(cl_api_path) as f:
        for row in csv.DictReader(f):
            sid = row['transactionId']
            if sid not in sessions_map:
                start = row['startTime'][:16].replace(' ', 'T')
                end   = row['stopTime'][:16].replace(' ', 'T')
                try:
                    kwh = float(row['consumedEnergyKilowattHours'])
                except ValueError:
                    kwh = 0.0
                try:
                    payment = float(row['billedTotalAmount'])
                except (ValueError, KeyError):
                    payment = 0.0
                sessions_map[sid] = {
                    'charger': row['chargerName'], 'start': start, 'end': end, 'kwh': kwh, 'payment': payment,
                }
    sessions = sorted(sessions_map.values(), key=lambda s: s['start'])
    print(f"ChargeLab sessions: {len(sessions)} loaded from {os.path.basename(cl_api_path)} (no report-*.csv, no interval data)")
else:
    print("WARNING: No report-*.csv or chargelab_transactions_*.csv found — sessions/intervals will be empty.")
    sessions = []

# ─── PRICING ANALYSIS ─────────────────────────────────────────────────────────
# ETL rate (2026) — Frozen Industrial, 1,000 kWh/Day Minimum
# Source: CSU Electric Tariff, Sheets 2.6, 2.17, 2.18, 3.1
ETL = {
    'eca_on':        0.0411,   # ECA on-peak $/kWh
    'eca_off':       0.0206,   # ECA off-peak $/kWh
    'ecc':           0.0048,   # Electric Capacity Charge $/kWh (all hours)
    'demand_on':     0.8954,   # on-peak demand $/kW/day
    'demand_off':    0.5820,   # off-peak demand $/kW/day
    'access_per_day': 3.7187,  # access & facilities $/day
}
ETL['energy_on']  = ETL['eca_on']  + ETL['ecc']   # 0.0459 $/kWh
ETL['energy_off'] = ETL['eca_off'] + ETL['ecc']   # 0.0254 $/kWh

# On-peak window: summer (Apr-Sep) 11am-6pm Mon-Fri; winter (Oct-Mar) 4pm-10pm Mon-Fri
# Pricing windows (weekdays):
#   csu_onpeak:   11am-6pm  — CSU on-peak billing window; higher energy rate
#   bldg_peak:    6pm-9pm   — building demand peaks observed here; off-peak energy rate
#   real_offpeak: 9pm-11am  — true off-peak; lowest cost
SUMMER_MONTHS = {4, 5, 6, 7, 8, 9}

def tod_window(dt):
    if dt.weekday() >= 5:
        return 'weekend'
    h = dt.hour
    if 11 <= h < 18:
        return 'csu_onpeak'    # 11am-6pm: CSU on-peak billing window
    elif 18 <= h < 21:
        return 'bldg_peak'     # 6pm-9pm: building demand peaks here (off-peak energy rate)
    else:
        return 'real_offpeak'  # 9pm-11am: true off-peak

def is_csu_onpeak(dt):
    summer = dt.month in SUMMER_MONTHS
    if dt.weekday() >= 5:
        return False
    if summer:
        return 11 <= dt.hour < 18
    else:
        return 16 <= dt.hour < 22

# kWh delivered per window
# Prefer 15-min interval data from report CSVs; fall back to session-level from API CSV.
kwh_by_window   = defaultdict(float)
sess_by_window  = defaultdict(int)
kwh_csu_onpeak  = 0.0
kwh_csu_offpeak = 0.0
seen_sess_window = {}

if report_csvs:
    # 15-min granularity path: iterate all report files
    seen_iv = set()
    for rpath in report_csvs:
        for row in dict_rows(rpath):
            kwh = float(row['Interval energy provided (kWh)'])
            sid = row['Session ID']
            ts  = datetime.strptime(
                row['Interval start date/time (YYYY-MM-DD hh:mm:ss) (local)'],
                '%Y-%m-%d %H:%M:%S')
            key = (sid, ts)
            if key in seen_iv:
                continue
            seen_iv.add(key)
            win = tod_window(ts)
            if kwh > 0:
                kwh_by_window[win] += kwh
                if is_csu_onpeak(ts):
                    kwh_csu_onpeak  += kwh
                else:
                    kwh_csu_offpeak += kwh
            if sid not in seen_sess_window:
                seen_sess_window[sid] = win
                sess_by_window[win] += 1
else:
    # Session-level fallback: use startTime from API CSV to assign window
    for s in sessions:
        sid = s['charger'] + s['start']  # proxy key
        try:
            ts = datetime.strptime(s['start'][:16], '%Y-%m-%dT%H:%M')
        except ValueError:
            continue
        win = tod_window(ts)
        kwh = s['kwh']
        if kwh > 0:
            kwh_by_window[win] += kwh
            if is_csu_onpeak(ts):
                kwh_csu_onpeak  += kwh
            else:
                kwh_csu_offpeak += kwh
        sess_by_window[win] += 1

# Session-level stats
kwh_vals = [s['kwh'] for s in sessions if s['kwh'] > 0]
n_sess        = len(kwh_vals)
total_kwh_all = sum(kwh_vals)
avg_kwh       = total_kwh_all / n_sess if n_sess else 0
median_kwh    = sorted(kwh_vals)[n_sess // 2] if n_sess else 0

# Derive days_sampled from actual session date range
if sessions:
    def _parse_start(s):
        raw = s['start'][:16]
        for fmt in ('%Y-%m-%dT%H:%M', '%Y-%m-%d %H:%M'):
            try:
                return datetime.strptime(raw, fmt)
            except ValueError:
                pass
        return None
    parsed = [_parse_start(s) for s in sessions]
    parsed = [d for d in parsed if d]
    if len(parsed) >= 2:
        days_sampled = max(1, (max(parsed) - min(parsed)).days + 1)
    else:
        days_sampled = 1
else:
    days_sampled = 1

monthly_scale    = 30 / days_sampled
monthly_sessions = round(n_sess * monthly_scale)
monthly_kwh      = round(total_kwh_all * monthly_scale)

# Alias for backwards compat with rest of script
total_kwh_9d = total_kwh_all

# CSU overlap: building demand vs. charger draw, computed from the actual overlap
# between CSU meter data and ChargeLab interval data (billed demand is bound by
# the CSU meter's date range, so that's the window used below).
csu_by_ts = {ts: kwh for ts, kwh in csu_raw}
charger_total_by_ts = defaultdict(float)
for _charger, _buckets in interval_buckets.items():
    for ts, kw in _buckets.items():
        charger_total_by_ts[ts] += kw

onpeak_rows, offpeak_rows = [], []
onpeak_total = onpeak_with_charger = 0
# kWh actually consumed per tariff window, building (whole meter) vs. chargers only —
# bounded to the CSU meter's own date range, used below for proportional cost-share.
building_kwh_by_window = defaultdict(float)
charger_kwh_by_window  = defaultdict(float)
for ts, kwh in csu_by_ts.items():
    dt = datetime.strptime(ts, '%Y-%m-%dT%H:%M')
    building_kw = kwh * 4  # 15-min kWh -> kW
    charger_kw = charger_total_by_ts.get(ts, 0.0)
    win = tod_window(dt)
    building_kwh_by_window[win] += kwh
    charger_kwh_by_window[win]  += charger_kw * 0.25  # kW -> 15-min kWh
    if is_csu_onpeak(dt):
        onpeak_rows.append((building_kw, charger_kw, ts))
        onpeak_total += 1
        if charger_kw > 0:
            onpeak_with_charger += 1
    else:
        offpeak_rows.append((building_kw, charger_kw, ts))

building_peak_onpeak_kw, charger_at_bldg_peak_kw, _onpeak_peak_ts = max(onpeak_rows, key=lambda r: r[0])
building_peak_offpeak_kw, charger_at_offpeak_peak_kw, _offpeak_peak_ts = max(offpeak_rows, key=lambda r: r[0])
combined_peak_onpeak_kw  = round(building_peak_onpeak_kw  + charger_at_bldg_peak_kw,    1)
combined_peak_offpeak_kw = round(building_peak_offpeak_kw + charger_at_offpeak_peak_kw, 1)
charger_peak_evening_kw  = round(max(charger_total_by_ts.values()), 1) if charger_total_by_ts else 0.0
# Chargers' own peak kW in each window, independent of the building's peak —
# used by "own-peak" demand allocation (assumes chargers aren't causing the
# building's billed peak; charges them for their own worst moment instead).
charger_peak_onpeak_kw  = round(max(r[1] for r in onpeak_rows),  1) if onpeak_rows  else 0.0
charger_peak_offpeak_kw = round(max(r[1] for r in offpeak_rows), 1) if offpeak_rows else 0.0
onpeak_intervals_charger_pct = round(onpeak_with_charger / onpeak_total * 100) if onpeak_total else 0

_first_ts = min(csu_by_ts) if csu_by_ts else None
_last_ts  = max(csu_by_ts) if csu_by_ts else None
demand_data_days = (
    (datetime.strptime(_last_ts, '%Y-%m-%dT%H:%M').date()
     - datetime.strptime(_first_ts, '%Y-%m-%dT%H:%M').date()).days + 1
) if _first_ts and _last_ts else 0

print(f"Demand coincidence ({demand_data_days}-day CSU overlap): "
      f"on-peak peak {building_peak_onpeak_kw:.1f} kW bldg + {charger_at_bldg_peak_kw:.1f} kW charger at {_onpeak_peak_ts}; "
      f"off-peak peak {building_peak_offpeak_kw:.1f} kW bldg + {charger_at_offpeak_peak_kw:.1f} kW charger at {_offpeak_peak_ts}; "
      f"{onpeak_intervals_charger_pct}% of on-peak intervals had charger activity")

# Demand cost allocation to chargers — proportional share, not causation:
# chargers are billed their share of each window's demand charge in proportion
# to how much of that window's kWh they actually consumed (their % of building
# load during on-peak hours, and their % during off-peak hours). This does NOT
# depend on whether they happened to be running at the exact moment of the
# building's billed peak. The daily access/facility charge is excluded entirely
# — that stays 100% on the building side.
# - On-peak demand ($0.8954/kW/day): measured during 11am-6pm Mon-Fri
# - Off-peak demand ($0.5820/kW/day): measured all other hours INCLUDING weekends
demand_on_monthly  = ETL['demand_on']  * 30   # $/kW/month
demand_off_monthly = ETL['demand_off'] * 30

charger_kwh_onpeak_total  = charger_kwh_by_window.get('csu_onpeak', 0.0)
charger_kwh_offpeak_total = (charger_kwh_by_window.get('bldg_peak',    0.0)
                             + charger_kwh_by_window.get('real_offpeak', 0.0)
                             + charger_kwh_by_window.get('weekend',      0.0))
building_kwh_onpeak_total  = building_kwh_by_window.get('csu_onpeak', 0.0)
building_kwh_offpeak_total = (building_kwh_by_window.get('bldg_peak',    0.0)
                              + building_kwh_by_window.get('real_offpeak', 0.0)
                              + building_kwh_by_window.get('weekend',      0.0))

onpeak_charger_share  = (charger_kwh_onpeak_total  / building_kwh_onpeak_total)  if building_kwh_onpeak_total  else 0
offpeak_charger_share = (charger_kwh_offpeak_total / building_kwh_offpeak_total) if building_kwh_offpeak_total else 0

onpeak_demand_total_monthly  = building_peak_onpeak_kw  * demand_on_monthly   # whole-building on-peak demand charge
offpeak_demand_total_monthly = building_peak_offpeak_kw * demand_off_monthly  # whole-building off-peak demand charge

demand_cost_on_monthly  = onpeak_demand_total_monthly  * onpeak_charger_share
demand_cost_off_monthly = offpeak_demand_total_monthly * offpeak_charger_share
total_demand_cost_monthly = demand_cost_on_monthly + demand_cost_off_monthly

# Alternate demand allocation: chargers' own peak kW in each window, independent
# of the building — assumes chargers are NOT causing the building's billed peak.
own_peak_demand_on_monthly  = charger_peak_onpeak_kw  * demand_on_monthly
own_peak_demand_off_monthly = charger_peak_offpeak_kw * demand_off_monthly
own_peak_total_demand_cost_monthly = own_peak_demand_on_monthly + own_peak_demand_off_monthly

kwh_csu_onpeak_mo   = kwh_by_window.get('csu_onpeak',   0) * monthly_scale
kwh_bldg_peak_mo    = kwh_by_window.get('bldg_peak',    0) * monthly_scale
kwh_real_offpeak_mo = kwh_by_window.get('real_offpeak', 0) * monthly_scale
kwh_weekend_mo      = kwh_by_window.get('weekend',      0) * monthly_scale
kwh_offpeak_total_mo = kwh_bldg_peak_mo + kwh_real_offpeak_mo + kwh_weekend_mo
kwh_total_monthly   = kwh_csu_onpeak_mo + kwh_offpeak_total_mo

# On-peak demand adder → spread over 11am-6pm kWh only
# Off-peak demand adder → spread over ALL off-peak kWh (weekday evening + overnight + weekend)
demand_adder_onpeak  = demand_cost_on_monthly  / kwh_csu_onpeak_mo   if kwh_csu_onpeak_mo   else 0
demand_adder_offpeak = demand_cost_off_monthly / kwh_offpeak_total_mo if kwh_offpeak_total_mo else 0
demand_adder_per_kwh = total_demand_cost_monthly / kwh_total_monthly  if kwh_total_monthly   else 0

cost_csu_onpeak   = round(ETL['energy_on']  + demand_adder_onpeak,  4)
cost_bldg_peak    = round(ETL['energy_off'] + demand_adder_offpeak, 4)
cost_real_offpeak = round(ETL['energy_off'] + demand_adder_offpeak, 4)
cost_weekend      = round(ETL['energy_off'] + demand_adder_offpeak, 4)

# Worst-case scenario: 3 chargers × 6.5 kW = 19.5 kW simultaneous
WORST_CASE_KW = 3 * 6.5  # 19.5 kW
wc_demand_cost_on_monthly  = WORST_CASE_KW * demand_on_monthly   # ~$524/month
wc_demand_cost_off_monthly = WORST_CASE_KW * demand_off_monthly  # ~$341/month
wc_demand_adder_onpeak  = wc_demand_cost_on_monthly  / kwh_csu_onpeak_mo   if kwh_csu_onpeak_mo   else 0
wc_demand_adder_offpeak = wc_demand_cost_off_monthly / kwh_offpeak_total_mo if kwh_offpeak_total_mo else 0

wc_cost_csu_onpeak   = round(ETL['energy_on']  + wc_demand_adder_onpeak,  4)
wc_cost_bldg_peak    = round(ETL['energy_off'] + wc_demand_adder_offpeak, 4)
wc_cost_real_offpeak = round(ETL['energy_off'] + wc_demand_adder_offpeak, 4)
wc_cost_weekend      = round(ETL['energy_off'] + wc_demand_adder_offpeak, 4)

# CMS fees
CMS_FLAT    = 0.30   # $ per session
CMS_PCT     = 0.029  # fraction of gross revenue

# Recommended pricing (to be set after reviewing true costs)
PRICE_CSU_ONPEAK   = 0.28   # 11am-6pm weekdays
PRICE_BLDG_PEAK    = 0.28   # 6pm-9pm weekdays
PRICE_REAL_OFFPEAK = 0.20   # 9pm-11am weekdays
PRICE_WEEKEND      = 0.20   # weekend flat

def net_per_session(price, avg_kwh_sess):
    gross = price * avg_kwh_sess
    cms   = CMS_FLAT + CMS_PCT * gross
    return round(gross - cms, 4)

sess_csu_onpeak   = sess_by_window.get('csu_onpeak',   0)
sess_bldg_peak    = sess_by_window.get('bldg_peak',    0)
sess_real_offpeak = sess_by_window.get('real_offpeak', 0)
sess_wkend        = sess_by_window.get('weekend',      0)

def monthly_net(price, n_sess_9d, avg_kwh_sess):
    return round(net_per_session(price, avg_kwh_sess) * n_sess_9d * monthly_scale, 0)

net_csu_onpeak   = monthly_net(PRICE_CSU_ONPEAK,   sess_csu_onpeak,   avg_kwh)
net_bldg_peak    = monthly_net(PRICE_BLDG_PEAK,    sess_bldg_peak,    avg_kwh)
net_real_offpeak = monthly_net(PRICE_REAL_OFFPEAK, sess_real_offpeak, avg_kwh)
net_wkend        = monthly_net(PRICE_WEEKEND,      sess_wkend,        avg_kwh)
net_total        = round(net_csu_onpeak + net_bldg_peak + net_real_offpeak + net_wkend, 0)

# Energy cost for the month, and the real (unscaled) cost over the actual
# sampled period — no 30-day extrapolation
energy_cost_monthly = round(
    kwh_csu_onpeak  * monthly_scale * ETL['energy_on'] +
    kwh_csu_offpeak * monthly_scale * ETL['energy_off'], 0)
energy_cost_real = round(
    kwh_csu_onpeak  * ETL['energy_on'] +
    kwh_csu_offpeak * ETL['energy_off'], 2)

# Real (unscaled) demand cost over the actual CSU-metered sample period
# (demand_data_days), for both allocation methods
demand_cost_on_real  = building_peak_onpeak_kw  * ETL['demand_on']  * demand_data_days * onpeak_charger_share
demand_cost_off_real = building_peak_offpeak_kw * ETL['demand_off'] * demand_data_days * offpeak_charger_share
total_demand_cost_real = demand_cost_on_real + demand_cost_off_real

own_peak_demand_on_real  = charger_peak_onpeak_kw  * ETL['demand_on']  * demand_data_days
own_peak_demand_off_real = charger_peak_offpeak_kw * ETL['demand_off'] * demand_data_days
own_peak_total_demand_cost_real = own_peak_demand_on_real + own_peak_demand_off_real

pricing_analysis = {
    # ETL rate constants
    'etlEnergyOn':      ETL['energy_on'],
    'etlEnergyOff':     ETL['energy_off'],
    'etlDemandOnDay':   ETL['demand_on'],
    'etlDemandOffDay':  ETL['demand_off'],
    'etlAccessPerDay':  ETL['access_per_day'],

    # Window definitions
    'windowCsuOnpeak':   '11am-6pm Mon-Fri (summer)',
    'windowBldgPeak':    '6pm-9pm Mon-Fri',
    'windowRealOffpeak': '9pm-11am Mon-Fri',
    'windowWeekend':     'Sat-Sun all day',

    # Session stats (9-day sample)
    'sessionCount9d':      n_sess,
    'totalKwh9d':          round(total_kwh_9d, 1),
    'avgKwhPerSession':    round(avg_kwh, 1),
    'medianKwhPerSession': round(median_kwh, 1),
    'daysSampled':         days_sampled,
    'monthlySessionsEst':  monthly_sessions,
    'monthlyKwhEst':       monthly_kwh,

    # kWh and sessions by window (9-day raw)
    'kwhByWindow9d': {
        'csu_onpeak':   round(kwh_by_window.get('csu_onpeak',   0), 1),
        'bldg_peak':    round(kwh_by_window.get('bldg_peak',    0), 1),
        'real_offpeak': round(kwh_by_window.get('real_offpeak', 0), 1),
        'weekend':      round(kwh_by_window.get('weekend',      0), 1),
    },
    'sessByWindow9d': {
        'csu_onpeak':   sess_csu_onpeak,
        'bldg_peak':    sess_bldg_peak,
        'real_offpeak': sess_real_offpeak,
        'weekend':      sess_wkend,
    },
    'pctKwhCsuOnpeak':  round(kwh_csu_onpeak  / total_kwh_9d * 100, 1),
    'pctKwhCsuOffpeak': round(kwh_csu_offpeak / total_kwh_9d * 100, 1),

    # Building demand data
    'buildingPeakOnpeakKw':      building_peak_onpeak_kw,
    'chargerAtOnpeakPeakKw':     charger_at_bldg_peak_kw,
    'combinedPeakOnpeakKw':      combined_peak_onpeak_kw,
    'buildingPeakOffpeakKw':     building_peak_offpeak_kw,
    'chargerAtOffpeakPeakKw':    charger_at_offpeak_peak_kw,
    'combinedPeakOffpeakKw':     combined_peak_offpeak_kw,
    'chargerPeakSimultaneousKw': charger_peak_evening_kw,
    'onpeakIntervalsChargerPct': onpeak_intervals_charger_pct,
    'demandDataDays':            demand_data_days,
    'onpeakPeakTimestamp':       _onpeak_peak_ts,
    'offpeakPeakTimestamp':      _offpeak_peak_ts,

    # Demand cost allocation
    'chargerShareOnpeakPct':  round(onpeak_charger_share  * 100, 1),
    'chargerShareOffpeakPct': round(offpeak_charger_share * 100, 1),
    'demandImpactOnMonthly':  round(demand_cost_on_monthly,  0),
    'demandImpactOffMonthly': round(demand_cost_off_monthly, 0),
    'totalDemandCostMonthly': round(total_demand_cost_monthly, 0),
    'demandAdderOnpeak':      round(demand_adder_onpeak,  4),
    'demandAdderOffpeak':     round(demand_adder_offpeak, 4),
    'demandAdderPerKwh':      round(demand_adder_per_kwh, 4),
    'kwhTotalMonthly':        round(kwh_total_monthly, 0),

    # Same demand allocation, but real $ over the actual sampled period —
    # no 30-day extrapolation
    'demandImpactOnReal':    round(demand_cost_on_real,  2),
    'demandImpactOffReal':   round(demand_cost_off_real, 2),
    'totalDemandCostReal':   round(total_demand_cost_real, 2),

    # Alternate: chargers' own peak kW demand allocation (Method 4)
    'chargerPeakOnpeakKw':          charger_peak_onpeak_kw,
    'chargerPeakOffpeakKw':         charger_peak_offpeak_kw,
    'ownPeakDemandOnMonthly':       round(own_peak_demand_on_monthly,  0),
    'ownPeakDemandOffMonthly':      round(own_peak_demand_off_monthly, 0),
    'ownPeakTotalDemandCostMonthly': round(own_peak_total_demand_cost_monthly, 0),
    'ownPeakDemandOnReal':          round(own_peak_demand_on_real,  2),
    'ownPeakDemandOffReal':         round(own_peak_demand_off_real, 2),
    'ownPeakTotalDemandCostReal':   round(own_peak_total_demand_cost_real, 2),

    # True fully-loaded cost per window (observed demand peak)
    'trueCostCsuOnpeak':   cost_csu_onpeak,
    'trueCostBldgPeak':    cost_bldg_peak,
    'trueCostRealOffpeak': cost_real_offpeak,
    'trueCostWeekend':     cost_weekend,
    'energyCostMonthly':   energy_cost_monthly,
    'energyCostReal':      energy_cost_real,

    # Worst-case true cost (3 chargers × 6.5 kW = 19.5 kW simultaneous)
    'worstCaseKw':            WORST_CASE_KW,
    'wcDemandCostOnMonthly':  round(wc_demand_cost_on_monthly,  0),
    'wcDemandCostOffMonthly': round(wc_demand_cost_off_monthly, 0),
    'wcTrueCostCsuOnpeak':    wc_cost_csu_onpeak,
    'wcTrueCostBldgPeak':     wc_cost_bldg_peak,
    'wcTrueCostRealOffpeak':  wc_cost_real_offpeak,
    'wcTrueCostWeekend':      wc_cost_weekend,

    # CMS fees
    'cmsFlatPerSession': CMS_FLAT,
    'cmsPct':            CMS_PCT,

    # Recommended pricing
    'priceCsuOnpeak':   PRICE_CSU_ONPEAK,
    'priceBldgPeak':    PRICE_BLDG_PEAK,
    'priceRealOffpeak': PRICE_REAL_OFFPEAK,
    'priceWeekend':     PRICE_WEEKEND,

    # Monthly revenue/net estimate
    'netMonthlyCsuOnpeak':   net_csu_onpeak,
    'netMonthlyBldgPeak':    net_bldg_peak,
    'netMonthlyRealOffpeak': net_real_offpeak,
    'netMonthlyWeekend':     net_wkend,
    'netMonthlyTotal':       net_total,
}

print(f"Pricing analysis: {n_sess} sessions, {total_kwh_9d:.1f} kWh over {days_sampled} days")
print(f"  kWh by window: csu_onpeak={kwh_by_window.get('csu_onpeak',0):.1f}  bldg_peak={kwh_by_window.get('bldg_peak',0):.1f}  real_offpeak={kwh_by_window.get('real_offpeak',0):.1f}  weekend={kwh_by_window.get('weekend',0):.1f}")
print(f"  True cost/kWh: csu_onpeak=${cost_csu_onpeak:.3f}  bldg_peak=${cost_bldg_peak:.3f}  real_offpeak=${cost_real_offpeak:.3f}  weekend=${cost_weekend:.3f}")
print(f"  Monthly net at recommended pricing: ${net_total:.0f}")

# ─── WRITE data.js ────────────────────────────────────────────────────────────

def js_obj(d, indent=2):
    """Render a Python dict as a JS object literal (no quotes on numeric values)."""
    parts = []
    for k, v in d.items():
        if isinstance(v, str):
            parts.append(f'{k}: {json.dumps(v)}')
        else:
            parts.append(f'{k}: {v}')
    pad = ' ' * indent
    return '{ ' + (', '.join(parts)) + ' }'

out = []
out.append('// AUTO-GENERATED by build_data.py — do not edit by hand')
_rpt_src = ', '.join(os.path.basename(p) for p in report_csvs) if report_csvs else 'none'
_sess_src = _rpt_src if report_csvs else (os.path.basename(api_csvs[-1]) if api_csvs else 'none')
out.append(f'// Sessions: {_sess_src}')
out.append(f'// 15-min intervals: {_rpt_src}')
out.append('')

# monthlyData
out.append('const monthlyData = [')
out.append('  // electricCost = electric-only from PDF bills; demandOnKw/demandXofKw back-calculated')
for d in monthly_data:
    out.append(f'  {js_obj(d)},')
out.append('];')
out.append('')

# csuRaw
out.append('// 15-min CSU meter readings: [datetime_local_MT, kWh]')
out.append('const csuRaw = [')
line_parts = []
for ts, kwh in csu_raw:
    line_parts.append(f'[{json.dumps(ts)},{kwh}]')
    if len(line_parts) == 3:
        out.append('  ' + ','.join(line_parts) + ',')
        line_parts = []
if line_parts:
    out.append('  ' + ','.join(line_parts) + ',')
out.append('];')
out.append('')

# sessions
out.append('// ChargeLab sessions — one row per session, times in local TZ')
out.append(f'// Source: {_sess_src}')
out.append('const sessions = [')
for s in sessions:
    out.append(f"  {{ charger: '{s['charger']}', start: '{s['start']}', end: '{s['end']}', kwh: {s['kwh']}, payment: {s.get('payment', 0.0)} }},")
out.append('];')
out.append('')

# pricingAnalysis
out.append('// Pricing analysis — computed by build_data.py from session + interval data')
out.append('// ETL rate constants, session stats, cost-per-window, and recommended pricing')
out.append('const pricingAnalysis = {')
for k, v in pricing_analysis.items():
    if isinstance(v, str):
        out.append(f'  {k}: {json.dumps(v)},')
    elif isinstance(v, dict):
        inner = ', '.join(
            f'{ik}: {json.dumps(iv) if isinstance(iv, str) else iv}'
            for ik, iv in v.items()
        )
        out.append(f'  {k}: {{ {inner} }},')
    else:
        out.append(f'  {k}: {v},')
out.append('};')
out.append('')

# realIntervalKwh
out.append('// Rolling 15-min average power (kW) per charger per bucket — measured directly from ChargeLab export')
out.append('// Keyed: charger → "YYYY-MM-DDTHH:MM" (local MT) → kW')
out.append('// Values are measured rolling 15-min average power (kW) — NOT kWh')
out.append('const realIntervalKwh = {  // name kept for backwards compat; values are now kW')
for charger in ['DQ-424', 'DQ-433', 'DQ-434', 'DQ-435']:
    out.append(f"  '{charger}': {{")
    for k in sorted(interval_buckets[charger]):
        v = round(interval_buckets[charger][k], 4)
        out.append(f"    '{k}': {v},")
    out.append('  },')
out.append('};')

output_path = os.path.join(BASE, 'data.js')
with open(output_path, 'w') as f:
    f.write('\n'.join(out) + '\n')

print(f"Written: {output_path} ({os.path.getsize(output_path):,} bytes)")