"""Synthetic wall-power sampling; original trapezoidal integration unchanged.

The saved 40 W, 600 s log supplies the fixed 1 s time grid. A hypothetical
triangle centered at 305 s exposes sampling error. No real server is measured.
"""
import csv
import math
import time
from pathlib import Path
from power_kernel import integrate

DEFAULT=dict(base_power_w=40,burst_power_w=0,burst_half_width_s=30,sampling='every_1s')
PERIODS={f'every_{n}s':n for n in (1,2,5,10,30,60)}
BOUNDS=dict(base_power_w=(0,200),burst_power_w=(0,400),burst_half_width_s=(1,120))
CENTER=305
DURATION=600


def validate(p):
    if not isinstance(p,dict) or set(p)!=set(DEFAULT) or not isinstance(p['sampling'],str) or p['sampling'] not in PERIODS:
        raise ValueError('Unknown or missing parameters')
    for k,(lo,hi) in BOUNDS.items():
        v=p[k]
        if type(v) not in (int,float) or not math.isfinite(v) or not lo<=v<=hi or v!=round(v):
            raise ValueError('Parameter out of range/off integer step: '+k)


def triangle_integral(t,half_width):
    """Exact integral in seconds of a unit-height triangle, from zero to t."""
    left,right=CENTER-half_width,CENTER+half_width
    if t<=left:return 0.
    if t<=CENTER:return (t-left)**2/(2*half_width)
    if t<right:return half_width-(right-t)**2/(2*half_width)
    return float(half_width)


def model_rows(p):
    validate(p)
    with Path(__file__).with_name('synthetic.csv').open(newline='') as f:
        saved=list(csv.DictReader(f))
    rows=[]
    for r in saved:
        t=float(r['time_s'])
        baseline=float(r['power_W'])*(p['base_power_w']/40)
        pulse=p['burst_power_w']*max(0.,1-abs(t-CENTER)/p['burst_half_width_s'])
        rows.append(dict(time_s=t,power_W=baseline+pulse))
    return rows


def run(name,p):
    if name!='power':raise ValueError('Unknown experiment')
    start=time.perf_counter()
    dense=model_rows(p)
    period=PERIODS[p['sampling']]
    rows=[r for r in dense if r['time_s']%period==0]
    # Same policy as the original 1 Hz logger: gap limit is two sample periods.
    max_gap=2*period
    result=integrate(rows,max_gap=max_gap)
    times=[r['time_s'] for r in rows]
    powers=[r['power_W'] for r in rows]
    # Use the kernel's sum semantics for each prefix (at most 600 intervals).
    # Plain += differs from Python's compensated sum on noninteger powers.
    areas=[dt*(a+b)/2 for dt,a,b in zip([b-a for a,b in zip(times,times[1:])],powers,powers[1:])]
    cumulative=[0.]+[sum(areas[:i])/3600 for i in range(1,len(areas)+1)]
    dense_times=[r['time_s'] for r in dense]
    reference=[(p['base_power_w']*t+p['burst_power_w']*triangle_integral(t,p['burst_half_width_s']))/3600 for t in dense_times]
    base_energy=p['base_power_w']*DURATION/3600
    def metric(ident,v,unit):return dict(id=ident,value=v,unit=unit)
    def series(ident,x,y,unit):return dict(id=ident,x=x,y=y,x_unit='s',y_unit=unit)
    return dict(metrics=[metric('power_duration_s',result['duration_s'],'s'),
                         metric('integrated_energy_wh',result['energy_Wh'],'Wh'),
                         metric('time_mean_w',result['mean_W'],'W'),
                         metric('sampled_peak_w',result['peak_sampled_W'],'W'),
                         metric('power_samples',result['samples'],'samples'),
                         metric('reference_energy_wh',reference[-1],'Wh'),
                         metric('energy_error_wh',result['energy_Wh']-reference[-1],'Wh'),
                         metric('incremental_energy_wh',result['energy_Wh']-base_energy,'Wh')],
                series=[series('sampled_power',times,powers,'W'),
                        series('reference_power',dense_times,[r['power_W'] for r in dense],'W'),
                        series('sampled_energy',times,cumulative,'Wh'),
                        series('reference_energy',dense_times,reference,'Wh')],
                stdout='',provenance=dict(data_type='synthetic',compute_ms=(time.perf_counter()-start)*1000,
                    original_result=result,max_gap_s=max_gap,sample_period_s=period,
                    reference_model='600 s, fixed 305 s triangle center, base W + excess peak W; analytic energy reference',
                    limitations='Synthetic point samples, not interval averages or server measurements. Triangle timing is fixed. No hardware-efficiency or cost model.'))


if __name__=='__main__':
    import argparse,json
    parser=argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--parameters',default=json.dumps(DEFAULT))
    print(json.dumps(run('power',json.loads(parser.parse_args().parameters)),allow_nan=False))