"""Deterministic synthetic sensible-cooling response experiment; stdlib only."""
import argparse,csv,json,math
from pathlib import Path

DEFAULT = {'duration_h':12,'dt_s':10,'initial_temp_c':24,'outside_temp_c':22,
 'setpoint_c':24,'band_low_c':23,'band_high_c':25,'capacitance_j_per_k':12000000,
 'ua_w_per_k':300,'base_heat_w':800,'light_heat_w':8000,'lights_on_h':2,
 'lights_off_h':8,'cooling_w':12000,'kp_per_k':0.6,'ki_per_k_s':0.0004}

def validate(c,tau):
    if set(c)!=set(DEFAULT):raise ValueError('config keys must match config.json')
    for k,v in {**c,'tau_s':tau}.items():
        if isinstance(v,bool) or not isinstance(v,(int,float)) or not math.isfinite(v):raise ValueError(k+': finite number required')
    if not 0<c['dt_s']<=60 or not 0<c['duration_h']<=48 or c['duration_h']*3600/c['dt_s']>20000:raise ValueError('time grid exceeds limits')
    if c['capacitance_j_per_k']<=0 or c['cooling_w']<=0 or c['ua_w_per_k']<0:raise ValueError('invalid thermal parameters')
    if any(c[k]<0 for k in ['base_heat_w','light_heat_w','kp_per_k','ki_per_k_s']) or tau<0:raise ValueError('negative capacity/gain/time constant')
    if not c['band_low_c']<c['setpoint_c']<c['band_high_c']:raise ValueError('invalid evaluation band')
    if not 0<=c['lights_on_h']<c['lights_off_h']<=c['duration_h']:raise ValueError('invalid light schedule')
    for h in [c['duration_h'],c['lights_on_h'],c['lights_off_h']]:
        if not math.isclose(h*3600/c['dt_s'],round(h*3600/c['dt_s']),abs_tol=1e-9):raise ValueError('events must align with grid')
    if c['ua_w_per_k']*c['dt_s']/c['capacitance_j_per_k']>0.1:raise ValueError('thermal Euler step too large')

def actuator(a,u,dt,tau):
    """End value and exact interval mean under zero-order-held command."""
    if tau==0:return u,u
    weight=-math.expm1(-dt/tau)
    return a+(u-a)*weight,u+(a-u)*(tau/dt)*weight

def integrate(i,e,raw,c):
    if 0<raw<1 or raw<=0 and e>0 or raw>=1 and e<0:
        return i+c['ki_per_k_s']*e*c['dt_s']
    return i

def run(c,tau):
    validate(c,tau);dt=c['dt_s'];t=c['initial_temp_c'];a=0.;integ=0.;prev=0.
    metrics={'max_temp_c':t,'min_temp_c':t,'outside_band_h':0.,'iae_k_h':0.,
      'cooling_thermal_kwh':0.,'command_actual_gap_h':0.,'command_total_variation':0.,
      'heat_balance_residual_j':0.}
    rows=[]
    for k in range(round(c['duration_h']*3600/dt)):
        seconds=k*dt;h=seconds/3600;e=t-c['setpoint_c'];raw=c['kp_per_k']*e+integ;u=max(0.,min(1.,raw))
        integ=integrate(integ,e,raw,c);end,avg=actuator(a,u,dt,tau)
        load=c['base_heat_w']+(c['light_heat_w'] if c['lights_on_h']<=h<c['lights_off_h'] else 0.)
        loss=c['ua_w_per_k']*(t-c['outside_temp_c']);net=load-loss-c['cooling_w']*avg
        next_t=t+net*dt/c['capacitance_j_per_k']
        metrics['outside_band_h']+=dt/3600 if not c['band_low_c']<=t<=c['band_high_c'] else 0.
        metrics['iae_k_h']+=abs(e)*dt/3600
        metrics['cooling_thermal_kwh']+=c['cooling_w']*avg*dt/3.6e6
        metrics['command_actual_gap_h']+=abs(u-avg)*dt/3600
        metrics['command_total_variation']+=abs(u-prev)
        metrics['heat_balance_residual_j']+=abs(c['capacitance_j_per_k']*(next_t-t)-net*dt)
        rows.append({'time_s':seconds,'temp_c':t,'command':u,'actual':a,'actual_interval_mean':avg,'load_w':load})
        t=next_t;a=end;prev=u
        metrics['max_temp_c']=max(metrics['max_temp_c'],t);metrics['min_temp_c']=min(metrics['min_temp_c'],t)
    metrics.update(tau_s=tau,final_temp_c=t)
    rows.append({'time_s':c['duration_h']*3600,'temp_c':t,'command':prev,'actual':a,'actual_interval_mean':a,'load_w':c['base_heat_w']})
    return metrics,rows

def compare(c):
    return {'scope':'synthetic sensible heat only; not crop or equipment performance','cases':[run(c,tau)[0] for tau in [0,300,900]]}

if __name__=='__main__':
    parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('config',nargs='?',type=Path,default=Path(__file__).with_name('config.json'));parser.add_argument('--tau',type=float);parser.add_argument('--csv',type=Path)
    args=parser.parse_args()
    try:
        c=json.loads(args.config.read_text())
        if args.csv and args.tau is None:raise ValueError('--csv requires --tau')
        if args.tau is None:result=compare(c)
        else:
            result,rows=run(c,args.tau)
            if args.csv:
                with args.csv.open('x',newline='') as f:
                    writer=csv.DictWriter(f,fieldnames=list(rows[0]));writer.writeheader();writer.writerows(rows)
        print(json.dumps(result,indent=2,allow_nan=False))
    except (ValueError,OSError) as e:parser.exit(2,str(e)+'\n')