#!/usr/bin/env python3
"""Independent structural, physical, temporal, missingness, and spatial QA for the release."""
from __future__ import annotations

import json
from pathlib import Path
import numpy as np
import pandas as pd

DATA = Path('air_quality_100m.npy')
META = Path('stations.csv')
GRAPH = Path('spatial_graph_knn10.csv')
OUT = Path('validation_report.json')
N_STATIONS = 1000
N_HOURS = 100_000
N_ROWS = N_STATIONS * N_HOURS
TZ = 'Asia/Kolkata'
FIELDS = ['temperature_c','relative_humidity_pct','wind_speed_ms','rainfall_mm','pm25_ugm3','pm10_ugm3','no2_ugm3','co_mgm3','so2_ugm3','o3_ugm3']
BITS = {f:i for i,f in enumerate(FIELDS)}
ALL_MASK = (1 << len(FIELDS)) - 1


def corr_lag(a, lag):
    a = np.asarray(a, dtype=np.float64)
    m = np.isfinite(a[:-lag]) & np.isfinite(a[lag:])
    if m.sum() < 10:
        return float('nan')
    return float(np.corrcoef(a[:-lag][m], a[lag:][m])[0,1])


def missing_run_lengths(mask_bool):
    x = np.asarray(mask_bool, dtype=np.int8)
    if not x.any(): return np.empty(0, dtype=np.int32)
    d = np.diff(np.r_[0, x, 0])
    starts = np.flatnonzero(d == 1); ends = np.flatnonzero(d == -1)
    return (ends - starts).astype(np.int32)


def haversine_pairs(meta, ids):
    lat = np.radians(meta.loc[ids,'latitude'].to_numpy(dtype=np.float64))
    lon = np.radians(meta.loc[ids,'longitude'].to_numpy(dtype=np.float64))
    out=[]
    for i in range(len(ids)):
        for j in range(i+1,len(ids)):
            dlat=lat[j]-lat[i]; dlon=lon[j]-lon[i]
            a=np.sin(dlat/2)**2 + np.cos(lat[i])*np.cos(lat[j])*np.sin(dlon/2)**2
            out.append(6371.0088*2*np.arcsin(np.sqrt(np.clip(a,0,1))))
    return np.asarray(out,dtype=np.float64)


def main():
    arr = np.load(DATA, mmap_mode='r')
    shape_ok = arr.shape == (N_ROWS,)
    mins={f:float('inf') for f in FIELDS}; maxs={f:float('-inf') for f in FIELDS}; sums={f:0. for f in FIELDS}; counts={f:0 for f in FIELDS}
    miss_counts={f:0 for f in FIELDS}
    violations={k:0 for k in ['pm_order','rh','temp','wind','rain','pollutant_negative','mask_nan_mismatch','bad_obs_mask_bits','bad_split','bad_event']}
    split_counts=np.zeros(3,dtype=np.int64); event_counts=np.zeros(5,dtype=np.int64)
    cap_counts={'pm25_950':0,'pm10_1200':0,'no2_250':0,'co_12':0,'so2_120':0,'o3_300':0}
    step=1_000_000
    for a in range(0,N_ROWS,step):
        x=arr[a:a+step]
        split_counts += np.bincount(x['split_code'],minlength=3)[:3]
        event_counts += np.bincount(x['event_code'],minlength=5)[:5]
        violations['bad_split'] += int(np.sum(x['split_code']>2))
        violations['bad_event'] += int(np.sum(x['event_code']>4))
        violations['bad_obs_mask_bits'] += int(np.sum((x['obs_mask'].astype(np.uint32) & np.uint32(~ALL_MASK & 0xFFFF)) != 0))
        obs_by={}
        for f,bit in BITS.items():
            obs=(x['obs_mask'] & np.uint16(1<<bit)) != 0
            obs_by[f]=obs
            finite=np.isfinite(x[f])
            miss_counts[f] += int((~obs).sum())
            violations['mask_nan_mismatch'] += int(np.sum(obs != finite))
            v=x[f][obs]
            if len(v):
                mins[f]=min(mins[f],float(np.min(v))); maxs[f]=max(maxs[f],float(np.max(v)))
                sums[f]+=float(np.sum(v,dtype=np.float64)); counts[f]+=len(v)
        both=obs_by['pm25_ugm3'] & obs_by['pm10_ugm3']
        violations['pm_order'] += int(np.sum(both & (x['pm10_ugm3'] < x['pm25_ugm3'])))
        rhobs=obs_by['relative_humidity_pct']; violations['rh'] += int(np.sum(rhobs & ((x['relative_humidity_pct']<0)|(x['relative_humidity_pct']>100))))
        tobs=obs_by['temperature_c']; violations['temp'] += int(np.sum(tobs & ((x['temperature_c']<-5)|(x['temperature_c']>50))))
        wobs=obs_by['wind_speed_ms']; violations['wind'] += int(np.sum(wobs & (x['wind_speed_ms']<0)))
        robs=obs_by['rainfall_mm']; violations['rain'] += int(np.sum(robs & (x['rainfall_mm']<0)))
        for f in ['pm25_ugm3','pm10_ugm3','no2_ugm3','co_mgm3','so2_ugm3','o3_ugm3']:
            violations['pollutant_negative'] += int(np.sum(obs_by[f] & (x[f]<0)))
        cap_counts['pm25_950'] += int(np.sum(obs_by['pm25_ugm3'] & np.isclose(x['pm25_ugm3'],950)))
        cap_counts['pm10_1200'] += int(np.sum(obs_by['pm10_ugm3'] & np.isclose(x['pm10_ugm3'],1200)))
        cap_counts['no2_250'] += int(np.sum(obs_by['no2_ugm3'] & np.isclose(x['no2_ugm3'],250)))
        cap_counts['co_12'] += int(np.sum(obs_by['co_mgm3'] & np.isclose(x['co_mgm3'],12)))
        cap_counts['so2_120'] += int(np.sum(obs_by['so2_ugm3'] & np.isclose(x['so2_ugm3'],120)))
        cap_counts['o3_300'] += int(np.sum(obs_by['o3_ugm3'] & np.isclose(x['o3_ugm3'],300)))

    # Exhaustive panel-key and split-code check.
    base_ts=arr[:N_HOURS]['timestamp_utc_s'].copy()
    expected_split=np.where(np.arange(N_HOURS)<80_000,0,np.where(np.arange(N_HOURS)<90_000,1,2)).astype(np.uint8)
    key_errors=0; split_structure_errors=0
    for sid in range(N_STATIONS):
        x=arr[sid*N_HOURS:(sid+1)*N_HOURS]
        if not np.all(x['station_id']==sid): key_errors+=1
        if not np.array_equal(x['timestamp_utc_s'],base_ts): key_errors+=1
        if not np.array_equal(x['split_code'],expected_split): split_structure_errors+=1
    cadence_ok=bool(np.all(np.diff(base_ts)==3600))
    order_consistency=1.0 if np.all(np.diff(base_ts)>=0) else float(np.mean(np.diff(base_ts)>=0))
    uniqueness=1.0 if len(np.unique(base_ts))==N_HOURS else len(np.unique(base_ts))/N_HOURS
    regularity=1.0 if cadence_ok else float(np.mean(np.diff(base_ts)==3600))
    grid_completeness=len(base_ts)/N_HOURS
    start_local=pd.to_datetime(int(base_ts[0]),unit='s',utc=True).tz_convert(TZ)
    end_local=pd.to_datetime(int(base_ts[-1]),unit='s',utc=True).tz_convert(TZ)

    meta=pd.read_csv(META)
    graph=pd.read_csv(GRAPH)
    graph_ok=(len(graph)==N_STATIONS*10 and (graph.source_station_id!=graph.target_station_id).all() and (graph.distance_km>0).all() and graph.groupby('source_station_id').size().eq(10).all())
    metadata_ok=(len(meta)==N_STATIONS and meta.station_id.nunique()==N_STATIONS and bool(meta.is_synthetic.all()))

    # Temporal / cross-channel diagnostics on station 0.
    x0=arr[:N_HOURS]
    idx_local=pd.to_datetime(base_ts,unit='s',utc=True).tz_convert(TZ)
    months=idx_local.month.to_numpy(); hours=idx_local.hour.to_numpy()
    acf={}
    for f in ['temperature_c','pm25_ugm3','no2_ugm3','o3_ugm3']:
        acf[f]={str(lag):corr_lag(x0[f],lag) for lag in [1,24,168]}
    corr_fields=['pm25_ugm3','pm10_ugm3','no2_ugm3','co_mgm3','so2_ugm3','o3_ugm3','wind_speed_ms','rainfall_mm']
    corr_df=pd.DataFrame({f:x0[f] for f in corr_fields}).corr()
    cross_corr={f:{g:float(corr_df.loc[f,g]) for g in corr_fields} for f in corr_fields}

    # First-difference diagnostics, pairwise valid successive hours.
    first_diff={}
    for f in ['temperature_c','pm25_ugm3','no2_ugm3','o3_ugm3']:
        a=x0[f].astype(np.float64); m=np.isfinite(a[:-1])&np.isfinite(a[1:]); d=a[1:][m]-a[:-1][m]
        first_diff[f]={'mean':float(d.mean()),'std':float(d.std()),'median_abs':float(np.median(np.abs(d))),'p99_abs':float(np.quantile(np.abs(d),.99))}

    # Monthly summaries and January extrema across 20 stations.
    df0=pd.DataFrame({'month':months,'temp':x0['temperature_c'],'rh':x0['relative_humidity_pct'],'rain':x0['rainfall_mm'],'pm25':x0['pm25_ugm3'],'pm10':x0['pm10_ugm3'],'no2':x0['no2_ugm3'],'o3':x0['o3_ugm3']})
    monthly=df0.groupby('month').agg(['mean','min','max']).round(3)
    jan=months==1; jan_min=float('inf'); jan_max=float('-inf')
    for sid in np.linspace(0,999,20,dtype=int):
        xx=arr[sid*N_HOURS:(sid+1)*N_HOURS]['temperature_c']
        jan_min=min(jan_min,float(np.nanmin(xx[jan]))); jan_max=max(jan_max,float(np.nanmax(xx[jan])))

    # Synthetic event-effect ratios on station 0, matched to non-event rows in the same calendar months.
    ev=x0['event_code']; event_effects={}
    for code,name in [(1,'diwali'),(2,'lockdown'),(3,'cyclone')]:
        em=ev==code
        if em.any():
            months_ev=np.unique(months[em]); ctrl=np.isin(months,months_ev)&(ev==0)
            res={}
            for f in ['pm25_ugm3','pm10_ugm3','no2_ugm3','co_mgm3','so2_ugm3','o3_ugm3']:
                bit=BITS[f]; om=(x0['obs_mask']&(1<<bit))!=0
                a=x0[f][em&om]; b=x0[f][ctrl&om]
                res[f]=float(np.nanmedian(a)/np.nanmedian(b))
            event_effects[name]=res

    # Missingness-run diagnostics on 20 stations.
    run_summary={f:[] for f in FIELDS}
    for sid in np.linspace(0,999,20,dtype=int):
        m=arr[sid*N_HOURS:(sid+1)*N_HOURS]['obs_mask']
        for f,bit in BITS.items():
            runs=missing_run_lengths((m&(1<<bit))==0)
            if len(runs): run_summary[f].extend(runs.tolist())
    run_stats={}
    for f,runs in run_summary.items():
        r=np.asarray(runs,dtype=np.float64)
        run_stats[f]={'n_runs':int(len(r)),'mean_hours':float(r.mean()),'median_hours':float(np.median(r)),'p95_hours':float(np.quantile(r,.95)),'max_hours':int(r.max())}

    # Spatial correlation decay on PM2.5. Raw and cross-sectionally residualized views.
    sample_ids=np.linspace(0,999,120,dtype=int)
    tidx=np.linspace(0,N_HOURS-1,6000,dtype=int)
    X=np.empty((len(tidx),len(sample_ids)),dtype=np.float32)
    for j,sid in enumerate(sample_ids):
        X[:,j]=arr[sid*N_HOURS:(sid+1)*N_HOURS]['pm25_ugm3'][tidx]
    raw_corr=pd.DataFrame(X).corr(min_periods=3000).to_numpy()
    residual=X-np.nanmean(X,axis=1,keepdims=True)
    residual_corr=pd.DataFrame(residual).corr(min_periods=3000).to_numpy()
    dists=haversine_pairs(meta,sample_ids)
    raw_pairs=[]; res_pairs=[]
    for i in range(len(sample_ids)):
        for j in range(i+1,len(sample_ids)):
            raw_pairs.append(raw_corr[i,j]); res_pairs.append(residual_corr[i,j])
    raw_pairs=np.asarray(raw_pairs,dtype=float); res_pairs=np.asarray(res_pairs,dtype=float)
    bins=[0,5,10,15,20,30,40,60]
    spatial_bins=[]
    for lo,hi in zip(bins[:-1],bins[1:]):
        m=(dists>=lo)&(dists<hi)&np.isfinite(raw_pairs)&np.isfinite(res_pairs)
        spatial_bins.append({'lo_km':lo,'hi_km':hi,'n_pairs':int(m.sum()),'raw_corr_mean':float(np.mean(raw_pairs[m])) if m.any() else None,'residual_corr_mean':float(np.mean(res_pairs[m])) if m.any() else None})
    spatial_raw_r=float(np.corrcoef(dists,raw_pairs)[0,1]); spatial_resid_r=float(np.corrcoef(dists,res_pairs)[0,1])
    near=np.isfinite(raw_pairs)&(dists<5); far=np.isfinite(raw_pairs)&(dists>=30)
    near_raw=float(np.mean(raw_pairs[near])); far_raw=float(np.mean(raw_pairs[far]))
    near_res=float(np.mean(res_pairs[near])); far_res=float(np.mean(res_pairs[far]))
    spatial_design_ok=(spatial_raw_r < -0.20 and near_raw > far_raw + 0.02 and near_res > far_res + 0.10)

    # Domain-level qualitative checks intentionally broad, not claims of empirical equivalence to real Kolkata data.
    relation_checks={
        'pm10_ge_pm25_all_joint_observations': violations['pm_order']==0,
        'pm25_wind_negative_corr_station0': cross_corr['pm25_ugm3']['wind_speed_ms'] < -0.05,
        'pm25_rain_negative_corr_station0': cross_corr['pm25_ugm3']['rainfall_mm'] < -0.02,
        'no2_o3_negative_corr_station0': cross_corr['no2_ugm3']['o3_ugm3'] < 0,
        'pm25_pm10_high_but_not_identical_corr_station0': 0.80 < cross_corr['pm25_ugm3']['pm10_ugm3'] < 0.9999,
        'spatial_distance_decay': spatial_design_ok,
    }

    hard_ok=(shape_ok and key_errors==0 and split_structure_errors==0 and cadence_ok and metadata_ok and graph_ok and all(v==0 for v in violations.values()) and all(relation_checks.values()))
    report={
        'status':'PASS' if hard_ok else 'FAIL',
        'scope':'internal synthetic-design validation; not an empirical equivalence claim against real Kolkata monitoring data',
        'rows':N_ROWS,'stations':N_STATIONS,'hours_per_station':N_HOURS,'file_size_bytes':DATA.stat().st_size,
        'start_local':str(start_local),'end_local':str(end_local),
        'timestamp_fidelity':{'order_consistency':order_consistency,'uniqueness':uniqueness,'regularity_consistency':regularity,'grid_completeness':grid_completeness,'key_errors':key_errors,'split_structure_errors':split_structure_errors},
        'split_rows':{'train':int(split_counts[0]),'validation':int(split_counts[1]),'test':int(split_counts[2])},
        'event_rows':{'normal':int(event_counts[0]),'diwali':int(event_counts[1]),'lockdown':int(event_counts[2]),'cyclone':int(event_counts[3]),'heatwave':int(event_counts[4])},
        'missingness':{
            'per_field_rows':miss_counts,
            'per_field_rates':{f:miss_counts[f]/N_ROWS for f in FIELDS},
            'run_length_sample20':run_stats,
        },
        'violations':violations,
        'min':mins,'max':maxs,'mean':{f:sums[f]/counts[f] for f in FIELDS},'cap_counts':cap_counts,
        'jan_temperature_sample20_minmax_c':[jan_min,jan_max],
        'autocorrelation_station0':acf,'first_difference_station0':first_diff,'cross_correlation_station0':cross_corr,
        'spatial_pm25':{'distance_vs_raw_corr_r':spatial_raw_r,'distance_vs_residual_corr_r':spatial_resid_r,'near_lt5km_raw':near_raw,'far_ge30km_raw':far_raw,'near_lt5km_residual':near_res,'far_ge30km_residual':far_res,'bins':spatial_bins,'design_check_pass':spatial_design_ok},
        'relation_checks':relation_checks,
        'station0_event_effect_median_ratios':event_effects,
        'station0_monthly':{str(m):{f'{col}_{stat}':float(monthly.loc[m,(col,stat)]) for col in ['temp','rh','rain','pm25','pm10','no2','o3'] for stat in ['mean','min','max']} for m in monthly.index},
        'metadata':{'rows':len(meta),'ok':metadata_ok,'site_type_counts':meta.site_type.value_counts().to_dict()},
        'graph':{'rows':len(graph),'k':10,'ok':bool(graph_ok),'distance_km_min':float(graph.distance_km.min()),'distance_km_max':float(graph.distance_km.max()),'distance_km_mean':float(graph.distance_km.mean())},
    }
    OUT.write_text(json.dumps(report,indent=2))
    print(json.dumps(report,indent=2))

if __name__=='__main__': main()