"""Causal daily economic family comparison using frozen plans and later physical data.

This is a labelled *simulation*, not savings on an invoice. A cohort is captured
near local midnight, uses only prices/forecasts then available, and all families
share initial storage, physical outcomes, tariff and constraints. No device calls.
Supported v1: one grid-charge-enabled battery; other topologies remain explicit.
"""
from dataclasses import asdict, replace
from datetime import datetime, timedelta
from hashlib import sha256
from math import sqrt
import json
from .domain import ZURICH, utc, month_key, quarter_start
from .selection import ReplayScore
from . import measurement_pipeline as m


def schema(con):
    con.executescript('''
    CREATE TABLE IF NOT EXISTS planner_economic_cohorts(
      plant TEXT NOT NULL, local_day TEXT NOT NULL, issued_at INTEGER NOT NULL,
      ends_at INTEGER NOT NULL, policy_id TEXT NOT NULL, value TEXT NOT NULL,
      PRIMARY KEY(plant,local_day));
    CREATE TABLE IF NOT EXISTS planner_economic_results(
      plant TEXT NOT NULL, local_day TEXT NOT NULL, evaluated_at INTEGER NOT NULL,
      policy_id TEXT NOT NULL, value TEXT NOT NULL, PRIMARY KEY(plant,local_day));
    CREATE TABLE IF NOT EXISTS planner_economic_attempts(
      plant TEXT NOT NULL, local_day TEXT NOT NULL, checked_at INTEGER NOT NULL,
      reason TEXT NOT NULL, PRIMARY KEY(plant,local_day));
    ''')


def _policy(data, cfg):
    batteries=[]
    for b in data['batteries']:
        v=asdict(b)
        for k in ('soc_percent','measured_at','discharge_blocked'):v.pop(k)
        batteries.append(v)
    return sha256(m.canonical({'battery':batteries,'limits':asdict(data['limits']),
        'mapping':cfg['mappingSha256'],'formula':cfg['formula'],'dataset':cfg['datasetId'],
        'method':'frozen_day_ahead_grid_tracking_v1','external':'sdl_request_estimate','peakTariffs':data['peak_prices']}).encode()).hexdigest()


def capture(store, plant, now, assemble, optimizer):
    settings=store.settings(plant)
    if settings.get('forecastSource')!='corrected_profile': return
    local=utc(now).astimezone(ZURICH); day=local.date().isoformat()
    # Freeze only at the beginning of a local day. Never reconstruct an old forecast from hindsight.
    if local.hour!=0 or local.minute>=15:return
    if store.con.execute('SELECT 1 FROM planner_economic_cohorts WHERE plant=? AND local_day=?',(plant,day)).fetchone():return
    attempted=store.con.execute('SELECT checked_at FROM planner_economic_attempts WHERE plant=? AND local_day=?',(plant,day)).fetchone()
    if attempted and now.timestamp()-attempted[0]<300:return
    reason='awaiting_comparable_snapshot'
    try:
        cfg=m.configuration(store.con,plant,settings['measurementDataset']);plans={}; common=None;policy=None
        end=datetime.combine(local.date()+timedelta(days=1),datetime.min.time(),tzinfo=ZURICH).astimezone(utc(now).tzinfo)
        for family in store.registry.entries():
            data,_,quality=assemble(store,plant,family.key,now)
            data['batteries']=[replace(b,roundtrip_efficiency=settings['roundtripEfficiency']) for b in data['batteries']]
            if len(data['batteries'])!=1 or not data['batteries'][0].grid_charging:
                raise ValueError('unsupported_replay_topology')
            if data['steps'][-1].end<end:raise ValueError('published_prices_do_not_cover_day')
            p=optimizer(**data,config_revision=settings['revision'],family=family.key,timeout_seconds=1.0)
            if not p.get('executable'):raise ValueError('candidate_not_feasible')
            points=[x for x in p['points'] if utc(x['time'])<end]
            p['points']=points
            if utc(points[-1]['validUntil'])!=end:raise ValueError('day_boundary_not_covered')
            this=_policy(data,cfg)
            if policy is not None and this!=policy:raise ValueError('inconsistent_candidate_context')
            policy=this
            initial=asdict(data['batteries'][0]);initial['measured_at']=utc(initial['measured_at']).isoformat()
            context={'battery':initial,'limits':asdict(data['limits']),'peaks':data['observed_peaks'],
                     'peakTariffs':data['peak_prices'],'quarterPast':{utc(k).isoformat():asdict(v) for k,v in data['quarter_history'].items()}}
            if common is not None and m.canonical(common)!=m.canonical(context):raise ValueError('different_initial_conditions')
            common=context;plans[family.key]=p
        billing=[[(p['time'],p['validUntil'],p['importPriceChfKwh'],p['exportPriceChfKwh']) for p in plan['points']] for plan in plans.values()]
        if any(v!=billing[0] for v in billing):raise ValueError('Different priced intervals between families')
        value={'datasetId':cfg['datasetId'],'start':next(iter(plans.values()))['points'][0]['time'],
               'end':end.isoformat(),'context':common,'plans':plans,'policyId':policy,
               'method':'frozen_day_ahead_grid_tracking_v1','actuation':False}
        with store.con:store.con.execute('INSERT INTO planner_economic_cohorts VALUES(?,?,?,?,?,?)',
                 (plant,day,int(now.timestamp()),int(end.timestamp()),policy,m.canonical(value)))
        reason='captured'
    except (ValueError,KeyError,TypeError):
        # No exception text copied from arbitrary data. Retry bounded to one attempt per five minutes.
        reason='awaiting_comparable_snapshot'
    with store.con:store.con.execute('INSERT INTO planner_economic_attempts VALUES(?,?,?,?) ON CONFLICT(plant,local_day) DO UPDATE SET checked_at=excluded.checked_at,reason=excluded.reason',
                                      (plant,day,int(now.timestamp()),reason))


def actuals(records,cfg):
    required=[s['key'] for s in cfg['sources'] if s['role'] in ('grid','physical_storage','sdl_request')]
    if sum(s['role']=='sdl_request' for s in cfg['sources'])!=1:raise ValueError('Missing SDL outcome source')
    def residual(values,c):
        grid=storage=external=0.0
        for s in c['sources']:
            role=s['role']
            if role not in ('grid','physical_storage','sdl_request'):continue
            x=values[s['key']]*s['factorToW']
            if role=='grid':grid+=x
            elif role=='physical_storage':storage+=x
            else:external+=x
        # External SDL is an explicitly estimated historical contribution, never called a meter.
        return grid-storage+external
    return m.reconstruct(records,cfg,projection={'keys':required,'calculate':residual})


def simulate(cohort,family,outcomes):
    plan=cohort['plans'][family];ctx=cohort['context'];b=ctx['battery'];limits=ctx['limits']
    capacity=b['capacity_kwh'];initial=energy=capacity*b['soc_percent']/100
    low=capacity*b['min_soc_percent']/100; high=capacity*b['max_soc_percent']/100
    eta=sqrt(b['roundtrip_efficiency']);peaks=dict(ctx['peaks']);quarter_max={};quarters={};money=wear=0.; coverage=[];breaches=0
    blocked=b['discharge_blocked'];rearm=capacity*(b['rearm_soc_percent'] or b['min_soc_percent'])/100
    for stamp,q in ctx['quarterPast'].items():quarters[stamp]=[q['import_kwh'],q['measured_seconds']]
    for p in plan['points']:
        start,end=utc(p['time']),utc(p['validUntil']);t=int(start.timestamp());seconds=int((end-start).total_seconds());dt=seconds/3600
        w=outcomes.get(t//300*300)
        if not w or not w['profileUsable'] or not m.numeric(w['loadW']):raise ValueError('Incomplete actual outcome')
        residual=w['loadW'];coverage.append(w['coverage'])
        charge=min(b['max_charge_w'],max(0.,(high-energy)/eta/dt*1000))
        if blocked and energy>=rearm-1e-9:blocked=False
        discharge=0. if blocked else min(b['max_discharge_w'],max(0.,(energy-low)*eta/dt*1000))
        target=p['gridTargetW'];cap=limits['import_w'];monthly=limits['manager_month_limits_w'].get(str(start.astimezone(ZURICH).month),limits['manager_month_limits_w'].get(start.astimezone(ZURICH).month))
        if monthly is not None:cap=monthly if cap is None else min(cap,monthly)
        if cap is not None:target=min(target,cap)
        if limits['export_w'] is not None:target=max(target,-limits['export_w'])
        battery=min(charge,max(-discharge,target-residual));grid=residual+battery
        energy+=battery/1000*dt*(eta if battery>=0 else 1/eta)
        if energy<low-1e-6 or energy>high+1e-6:raise ValueError('Replay SOC invariant')
        if energy<=low+1e-9:blocked=True
        if cap is not None and grid>cap+1.:breaches+=1
        if limits['export_w'] is not None and grid < -limits['export_w']-1.:breaches+=1
        money+=(max(grid,0)*p['importPriceChfKwh']-max(-grid,0)*p['exportPriceChfKwh'])/1000*dt
        wear+=abs(battery)/1000*dt*b['throughput_chf_kwh']
        q=quarter_start(start).isoformat();v=quarters.setdefault(q,[0.,0]);v[0]+=max(grid,0)/1000*dt;v[1]+=seconds
        if end==quarter_start(start)+timedelta(minutes=15):
            if v[1]!=900:raise ValueError('Incomplete simulated billing quarter')
            month=month_key(start);peaks[month]=max(peaks[month],v[0]/.25);quarter_max[month]=max(quarter_max.get(month,0.),v[0]/.25)
    additional=sum(max(0,v-ctx['peaks'][month])*ctx['peakTariffs'][month] for month,v in peaks.items())
    # Identical terminal valuation for all families, known at cohort creation; separate from cash.
    last=plan['points'][-1];buy=max(0.,last['importPriceChfKwh']);sell=max(0.,min(buy,last['exportPriceChfKwh']))
    terminal=max(initial-energy,0)/eta*buy-max(energy-initial,0)*eta*sell
    return {'cashCostChf':money+additional,'energyCostChf':money,'peakCostChf':additional,'throughputCostChf':wear,
            'terminalAdjustmentChf':terminal,'costChf':money+additional+wear+terminal,
            'initialEnergyKwh':initial,'finalEnergyKwh':energy,'coverage':min(coverage),
            'quarterMaximaKw':quarter_max,'initialPeaksKw':ctx['peaks'],'peakTariffs':ctx['peakTariffs'],
            'constraintBreaches':breaches,'terminalNormalized':True,
            'terminalMethod':'common_known_end_price_inventory_valuation_not_physical_restoration'}


def advance(store,plant,now):
    timestamp=int(now.timestamp())
    rows=store.con.execute('SELECT c.* FROM planner_economic_cohorts c LEFT JOIN planner_economic_results r USING(plant,local_day) WHERE c.plant=? AND c.ends_at<=? AND c.ends_at>=? AND r.local_day IS NULL AND NOT EXISTS(SELECT 1 FROM planner_economic_attempts a WHERE a.plant=c.plant AND a.local_day=c.local_day AND a.checked_at>?) ORDER BY c.issued_at LIMIT 1',(plant,timestamp-120,timestamp-90*86400,timestamp-300)).fetchall()
    for row in rows:
        with store.con:store.con.execute('INSERT INTO planner_economic_attempts VALUES(?,?,?,?) ON CONFLICT(plant,local_day) DO UPDATE SET checked_at=excluded.checked_at,reason=excluded.reason',(plant,row['local_day'],timestamp,'evaluating_actuals'))
        try:
            cohort=json.loads(row['value']);cfg=m.configuration(store.con,plant,cohort['datasetId']);source=cfg.get('sourceDatasetId',cfg['datasetId']);start=m.epoch(cohort['start']);end=m.epoch(cohort['end'])
            observed=store.con.execute('SELECT value FROM planner_observations WHERE plant=? AND dataset=? AND captured_at>=? AND captured_at<=? AND received_at<=? ORDER BY captured_at',(plant,source,start-600,end+600,timestamp))
            windows=actuals([json.loads(r[0]) for r in observed],cfg);outcomes={w['start']:w for w in windows}
            results={f:simulate(cohort,f,outcomes) for f in cohort['plans']}
            value={'status':'evaluated','results':results,'start':cohort['start'],'end':cohort['end'],
                   'evaluationBasis':'physical_balance_with_sdl_request_estimate','method':cohort['method'],
                   'actualCashSavings':False,'controlEnabled':False}
            with store.con:store.con.execute('INSERT INTO planner_economic_results VALUES(?,?,?,?,?)',(plant,row['local_day'],timestamp,row['policy_id'],m.canonical(value)))
        except (ValueError,KeyError,TypeError):
            # Retain unscored cohort. Lack of actual data must never become a zero cost.
            pass


def scores(store,plant,now):
    settings=store.settings(plant)
    if settings.get('forecastSource')!='corrected_profile':return []
    since=int((utc(now)-timedelta(days=settings['autoLookbackDays'])).timestamp())
    recent=store.con.execute('SELECT policy_id,value FROM planner_economic_cohorts WHERE plant=? ORDER BY issued_at DESC LIMIT 1',(plant,)).fetchone()
    if not recent or json.loads(recent[1])['datasetId']!=settings.get('measurementDataset'):return []
    rows=store.con.execute('SELECT c.issued_at,c.ends_at,r.evaluated_at,r.value FROM planner_economic_results r JOIN planner_economic_cohorts c USING(plant,local_day) WHERE r.plant=? AND r.policy_id=? AND c.issued_at>=? AND r.evaluated_at<=? ORDER BY c.issued_at',(plant,recent[0],since,int(now.timestamp()))).fetchall()
    if not rows:return []
    keys=[f.key for f in store.registry.entries()];valid=[]
    for r in rows:
        v=json.loads(r['value']);out=v['results']
        if set(out)!=set(keys) or any(out[k]['constraintBreaches'] for k in keys):continue
        valid.append((r,v))
    if not valid:return []
    result=[]
    for k in keys:
        # Monthly demand cost is paid ONCE for the maximum, not once per replay day.
        total=sum(v['results'][k]['energyCostChf']+v['results'][k]['throughputCostChf']+v['results'][k]['terminalAdjustmentChf'] for _,v in valid)
        bases={}; maxima={}; rates={}
        for _,v in valid:
            d=v['results'][k]
            for month,peak in d['quarterMaximaKw'].items():
                bases.setdefault(month,d['initialPeaksKw'][month])
                maxima[month]=max(maxima.get(month,0.),peak);rates[month]=d['peakTariffs'][month]
        total+=sum(max(0.,maxima[month]-bases[month])*rates[month] for month in maxima)
        cover=min(v['results'][k]['coverage'] for _,v in valid)
        first=utc(valid[0][1]['start']);end=utc(valid[-1][1]['end']);available=datetime.fromtimestamp(max(r['evaluated_at'] for r,_ in valid),utc(now).tzinfo)
        result.append(ReplayScore(k,recent[0],first,end,first,available,total,cover,len(valid)))
    return result


def status(store,plant):
    rows=store.con.execute('SELECT local_day,value FROM planner_economic_results WHERE plant=? ORDER BY local_day DESC LIMIT 14',(plant,))
    evaluated=[{'day':r[0],**json.loads(r[1])} for r in rows]
    count=store.con.execute('SELECT COUNT(*) FROM planner_economic_cohorts WHERE plant=?',(plant,)).fetchone()[0]
    return {'connected':True,'method':'frozen_day_ahead_grid_tracking_v1','cohorts':count,'completedComparisons':evaluated,
            'evaluationBasis':'physical_balance_with_sdl_request_estimate','isBillingEvidence':False,
            'limitations':['one_grid_charging_battery','frozen_daily_plan_not_receding_horizon_field_replay']}