"""Compare independent metrics with upstream analysis on retained tiny-run data.

Read-only datastore use. No simulator invocation and no datastore.save().
The original Figure 4 numerical prelude is extracted unmodified with AST;
only a return-locals statement is appended, before any plotting instructions.
"""
import argparse
import ast
import copy
import datetime
import gzip
import hashlib
import json
import logging
from pathlib import Path
from types import SimpleNamespace
import sys
import numpy as np
from metrics import spike_metrics, analog_metrics


def sha(path):
    return hashlib.sha256(path.read_bytes()).hexdigest()


def scalar(x):
    if x is None:
        return None
    x = float(x)
    return x if np.isfinite(x) else None


def main():
    p = argparse.ArgumentParser(description=__doc__)
    p.add_argument('--datastore', type=Path, required=True)
    p.add_argument('--figure-source', type=Path, required=True)
    p.add_argument('--framework', type=Path, required=True)
    p.add_argument('--output', type=Path, required=True)
    args = p.parse_args()
    sys.path.insert(0, str(args.framework.resolve()))
    out = args.output.resolve(); out.mkdir(parents=True, exist_ok=True)
    before = {f.name: sha(f) for f in args.datastore.iterdir() if f.is_file()}
    from tests.full_model.test_models import TestModel
    from parameters import ParameterSet
    from mozaik.storage.queries import param_filter_query
    import mozaik.storage.queries as queries
    from mozaik.analysis.analysis import (TrialAveragedFiringRate, PSTH,
        Analog_MeanSTDAndFanoFactor, NeuronToNeuronAnalogSignalCorrelations,
        PopulationMeanAndVar)
    import matplotlib.gridspec as gridspec

    ds = TestModel.load_datastore(str(args.datastore))
    pops = [('V1_Exc_L4', 'L4E'), ('V1_Inh_L4', 'L4I'),
            ('V1_Exc_L2/3', 'L23E'), ('V1_Inh_L2/3', 'L23I')]
    view = param_filter_query(ds, sheet_name=[x[0] for x in pops],
                              st_name='InternalStimulus', st_direct_stimulation_name=None)
    assert len(view.get_segments()) == 4, 'Expected one spontaneous segment per cortical population'
    # Invoke the actual pinned framework algorithms; results stay in memory.
    TrialAveragedFiringRate(view, ParameterSet({})).analyse()
    Analog_MeanSTDAndFanoFactor(view, ParameterSet({})).analyse()
    PSTH(view, ParameterSet({'bin_length': 10.0})).analyse()
    # Views snapshot ADS lists: re-query the full datastore after adding results.
    fresh = param_filter_query(ds, sheet_name=[x[0] for x in pops],
                              st_name='InternalStimulus', st_direct_stimulation_name=None)
    NeuronToNeuronAnalogSignalCorrelations(param_filter_query(fresh, analysis_algorithm='PSTH'),
        ParameterSet({'convert_nan_to_zero': True})).analyse()
    PopulationMeanAndVar(param_filter_query(fresh, identifier='PerNeuronValue'),
                         ParameterSet({'ignore_nan_and_inf': False})).analyse()

    tree = ast.parse(args.figure_source.read_text())
    cls = next(x for x in tree.body if isinstance(x, ast.ClassDef) and x.name == 'SpontStatisticsOverview')
    method = next(x for x in cls.body if isinstance(x, ast.FunctionDef) and x.name == 'subplot')
    # This pinned source's last numerical statement logs mean_ICond at line 549.
    prefix = [copy.deepcopy(x) for x in method.body if x.end_lineno <= 549]
    assert prefix[-1].lineno == 549, 'Unexpected figure source; review extraction boundary'
    fn = ast.FunctionDef(name='upstream_statistics', args=copy.deepcopy(method.args),
        body=prefix+[ast.Return(value=ast.Call(func=ast.Name(id='locals', ctx=ast.Load()), args=[], keywords=[]))],
        decorator_list=[])
    mod = ast.fix_missing_locations(ast.Module(body=[fn], type_ignores=[]))
    namespace = {'numpy': np, 'queries': queries, 'param_filter_query': param_filter_query,
                 'gridspec': gridspec, 'logger': logging.getLogger('upstream-figure4')}
    exec(compile(mod, str(args.figure_source), 'exec'), namespace)
    upstream = namespace['upstream_statistics'](SimpleNamespace(datastore=ds), gridspec.GridSpec(1, 1)[0])

    # Fixed numerical parity criterion, specified before inspecting results.
    # A floating-point analysis tolerance, not a biological equivalence margin.
    atol, rtol = 1e-10, 1e-12
    comparisons, populations, export = [], [], []
    metrics = [('firing_rate_hz','firing_rate',1), ('isi_cv','CV',1),
               ('pairwise_correlation','CC',1), ('voltage_mV','VM',1),
               ('exc_conductance_nS','CondE',1000), ('inh_conductance_nS','CondI',1000)]
    for population, suffix in pops:
        seg = param_filter_query(view, sheet_name=population).get_segments()[0]
        ids = [int(x) for x in seg.get_stored_spike_train_ids()]
        raw_ids = [int(s.annotations['source_id']) for s in seg.spiketrains]
        assert ids == raw_ids, 'Original mask and stored spike-ID order disagree'
        corr = param_filter_query(ds, sheet_name=population, st_name='InternalStimulus',
            value_name='Correlation coefficient(psth (bin=10.0))', ads_unique=True).get_analysis_result()[0]
        assert [int(i) for i in corr.ids] == ids, 'Correlation matrix IDs are misaligned'
        trains = [seg.get_spiketrain(i) for i in ids]
        start, stop = [float(x.rescale('ms')) for x in (trains[0].t_start, trains[0].t_stop)]
        assert all(float(t.t_start.rescale('ms')) == start and float(t.t_stop.rescale('ms')) == stop for t in trains)
        spikes = [{'id': i, 'times_ms': np.asarray(t.rescale('ms').magnitude).tolist()} for i,t in zip(ids,trains)]
        independent = spike_metrics(spikes, start, stop, bin_policy='upstream_range')
        record = {'population': population, 'segment': str(seg.identifier),
                  'stimulus': str(seg.annotations['stimulus']), 'spike_ids_aligned': True,
                  'spike_metrics': independent, 'analog': {}}
        raw = {'population': population, 'segment': str(seg.identifier),
               'window_ms': [start,stop], 'spikes': spikes, 'analog': {}}
        for metric, ids_fn, get_fn, unit in [
            ('voltage_mV','get_stored_vm_ids','get_vm','mV'),
            ('exc_conductance_nS','get_stored_esyn_ids','get_esyn','uS'),
            ('inh_conductance_nS','get_stored_isyn_ids','get_isyn','uS')]:
            analog = []
            for i in getattr(seg, ids_fn)():
                signal = getattr(seg, get_fn)(i)
                values = np.asarray(signal.rescale(unit).magnitude).reshape(-1)
                times = np.asarray(signal.times.rescale('ms').magnitude).reshape(-1)
                assert len(values) == len(times) and np.all(np.diff(times) > 0)
                assert times[0] >= start and times[-1] <= stop
                period = float(signal.sampling_period.rescale('ms'))
                assert np.allclose(np.diff(times), period, rtol=0, atol=1e-9)
                analog.append({'id':int(i),'values':values.tolist(),'unit':unit,
                    'first_sample_ms':float(times[0]),'last_sample_ms':float(times[-1]),
                    't_start_ms':float(signal.t_start.rescale('ms')),
                    't_stop_ms':float(signal.t_stop.rescale('ms')),'sample_period_ms':period})
            assert len({(x['first_sample_ms'],x['last_sample_ms'],len(x['values'])) for x in analog}) == 1
            independent[metric] = analog_metrics(analog, unit)
            record['analog'][metric] = {'neurons':len(analog),'samples':sum(len(x['values']) for x in analog),
                                       'timing':{k:v for k,v in analog[0].items() if k not in ('values','id')}}
            raw['analog'][metric] = analog
        for metric, upstream_name, factor in metrics:
            for stat, prefix_name in [('mean','mean'),('sd','std')]:
                a = scalar(independent[metric][stat])
                b = scalar(upstream[prefix_name+'_'+upstream_name+'_'+suffix]*factor)
                finite = a is not None and b is not None
                passed = bool(np.isclose(a,b,atol=atol,rtol=rtol)) if finite else a is None and b is None
                comparisons.append({'population':population,'metric':metric,'statistic':stat,
                    'independent':a,'upstream':b,'finite':finite,'pass':passed,
                    'absolute_difference':abs(a-b) if finite else None})
        populations.append(record); export.append(raw)
    # Also check the width of the retained 210-ms controls with actual upstream PSTHs.
    from mozaik.analysis.helper_functions import psth
    controls=[]
    for population,_ in pops:
        for seg in TestModel().get_segments(ds,population):
            if 'FullfieldDriftingSinusoidalGrating' not in str(seg.annotations['stimulus']):continue
            t=seg.spiketrains[0]; h=psth([t],10.0)[0]
            duration=float((t.t_stop-t.t_start).rescale('ms'))
            controls.append({'population':population,'segment':str(seg.identifier),
                'duration_ms':duration,'bins':len(h),'effective_bin_ms':duration/len(h)})
    after = {f.name:sha(f) for f in args.datastore.iterdir() if f.is_file()}
    assert before == after, 'Retained datastore files changed'
    result = {'scope':'analysis parity on retained small-model recordings; no new neural run',
        'original_run':'20261007T235207Z-8aa25b84','date_utc':datetime.datetime.now(datetime.timezone.utc).isoformat(),
        'python':sys.version,'numpy':np.__version__,'tolerance':{'atol':atol,'rtol':rtol,'meaning':'numerical analysis parity only'},
        'upstream_source':{'sha256':sha(args.figure_source),'class':'SpontStatisticsOverview','method':'subplot','last_included_line':549},
        'input_datastore_hashes':before,'input_unchanged':True,'populations':populations,
        'comparisons':comparisons,'finite_comparisons':sum(x['finite'] for x in comparisons),
        'passed':sum(x['pass'] for x in comparisons),'total':len(comparisons),'all_passed':all(x['pass'] for x in comparisons),
        'grating_bin_controls':controls,'full_model_benchmark_pass':None}
    (out/'analysis-parity.json').write_text(json.dumps(result,indent=2,allow_nan=False)+'\n')
    with gzip.open(out/'exported-recordings.json.gz','wt') as f:json.dump(export,f,allow_nan=False)
    print(json.dumps({k:result[k] for k in ['passed','total','finite_comparisons','all_passed','input_unchanged']}))
    if not result['all_passed']:raise SystemExit(1)


if __name__ == '__main__':
    main()
