"""Synthetic checks of vm_synchrony.py (no model data):  python3 -m unittest -v test_vm_synchrony"""
import gzip, hashlib, json, tempfile, unittest
from pathlib import Path
import numpy as np
import vm_synchrony as vs


def ou(n, tau, rng, dt=1.0):
    """Ornstein-Uhlenbeck process with unit variance and correlation time tau (ms)."""
    a = np.exp(-dt / tau)
    x = np.empty(n)
    x[0] = rng.standard_normal()
    noise = rng.standard_normal(n) * np.sqrt(1 - a * a)
    for t in range(1, n):
        x[t] = a * x[t - 1] + noise[t]
    return x


class SignalSteps(unittest.TestCase):
    def setUp(self):
        self.rng = np.random.default_rng(1)

    def test_spike_removal_interpolates_linearly(self):
        v = np.linspace(-70, -60, 101)
        spiky = v.copy()
        spiky[48:53] = [-40, 20, -60, -60, -59]
        np.testing.assert_allclose(vs.remove_spikes(spiky, 0.0, [50.0]), v, atol=1e-12)
        self.assertTrue(np.array_equal(vs.remove_spikes(v, 0.0, []), v))

    def test_spike_removal_hold_mode(self):
        v = np.linspace(-70, -60, 101)
        held = vs.remove_spikes(v, 0.0, [50.0], mode='hold')
        self.assertTrue(np.all(held[48:53] == v[47]))
        self.assertTrue(np.array_equal(held[:48], v[:48]) and np.array_equal(held[53:], v[53:]))

    def test_spike_windows_merge_and_edges(self):
        v = np.arange(20, dtype=float)
        out = vs.remove_spikes(v, 0.0, [1.0, 5.0, 18.5])     # first window touches the start, last the end
        self.assertTrue(np.all(out[:4] == out[4]))
        self.assertEqual(out[-1], out[15])

    def test_fft_crosscorrelation_matches_direct_formula(self):
        x, y = self.rng.standard_normal(40_000), self.rng.standard_normal(40_000)
        lags, r = vs.xcorr_from_spectra(vs.block_spectra(x), vs.block_spectra(y), maxlag=30)
        bx, by = vs.normalized_blocks(x), vs.normalized_blocks(y)
        direct = []
        for lag in lags:
            if lag >= 0:
                direct.append(np.mean([np.dot(bx[b, lag:], by[b, :1000 - lag]) for b in range(40)]))
            else:
                direct.append(np.mean([np.dot(by[b, -lag:], bx[b, :1000 + lag]) for b in range(40)]))
        np.testing.assert_allclose(r, direct, atol=1e-10)

    def test_shared_component_gives_expected_peak_and_width(self):
        s = ou(40_320, 20.0, self.rng)
        x, y = s + ou(40_320, 20.0, self.rng), s + ou(40_320, 20.0, self.rng)
        lags, r = vs.xcorr_from_spectra(vs.block_spectra(x), vs.block_spectra(y))
        peak, lag, width = vs.peak_and_width(lags, r)
        self.assertAlmostEqual(peak, 0.5, delta=0.06)          # half of each trace's variance is shared
        self.assertLessEqual(abs(lag), 2)
        self.assertAlmostEqual(width, 2 * 20.0 * np.log(2), delta=6.0)   # exponential correlation, tau = 20 ms

    def test_width_none_for_negative_peak(self):
        lags = np.arange(-50, 51)
        self.assertIsNone(vs.peak_and_width(lags, -np.exp(-np.abs(lags) / 10.0))[2])

    def test_highpass_removes_shared_slow_component(self):
        fast_x, fast_y = ou(40_320, 3.0, self.rng), ou(40_320, 3.0, self.rng)
        slow = 3 * np.sin(2 * np.pi * 2.0 * np.arange(40_320) / 1000.0)
        lags, r = vs.xcorr_from_spectra(vs.block_spectra(fast_x + slow), vs.block_spectra(fast_y + slow))
        self.assertGreater(vs.peak_and_width(lags, r)[0], 0.8)
        lags, rh = vs.xcorr_from_spectra(vs.block_spectra(vs.highpass(fast_x + slow)), vs.block_spectra(vs.highpass(fast_y + slow)))
        self.assertLess(vs.peak_and_width(lags, rh)[0], 0.15)

    def test_coherence_identical_and_independent(self):
        x, y = self.rng.standard_normal(40_320), self.rng.standard_normal(40_320)
        sx, freqs = vs.taper_spectra(x)
        sy, _ = vs.taper_spectra(y)
        self.assertGreater(vs.band_mean(freqs, vs.coherence(sx, sx), vs.HIGH_BAND), 0.999)
        self.assertLess(vs.band_mean(freqs, vs.coherence(sx, sy), vs.HIGH_BAND), 0.12)
        self.assertEqual(freqs[-1], 100.0)
        self.assertEqual(len(freqs), 101)

    def test_autocorrelation_tau_recovered(self):
        x = ou(40_320, 30.0, self.rng)
        tau, ac, status = vs.autocorrelation_tau(x)
        self.assertEqual(status, 'ok')
        self.assertAlmostEqual(tau, 30.0, delta=4.5)          # unbiased estimate (primary)
        self.assertAlmostEqual(ac[0], 1.0, places=6)
        tau_coeff, _, _ = vs.autocorrelation_tau(x, unbiased=False)
        self.assertLess(tau_coeff, tau)                         # 'coeff' tapers long lags and shortens tau

    def test_fit_at_bound_is_a_failure(self):
        self.assertEqual(vs.fit_exponential(np.ones(101))[1], 'at_bound')        # no decay: c runs to its upper bound
        self.assertEqual(vs.fit_exponential(np.exp(-np.arange(101) / 25.0))[1], 'ok')

    def test_pairs_within_distance(self):
        g = np.arange(0, 2001, 100.0)
        x, y = [a.ravel() for a in np.meshgrid(g, g)]
        i, j, d = vs.pairs_within(x, y, x, y, same=True)
        brute = sum(1 for a in range(len(x)) for b in range(a + 1, len(x)) if np.hypot(x[a] - x[b], y[a] - y[b]) <= 500)
        self.assertEqual(len(i), brute)
        self.assertTrue(np.all(i < j) and np.all(d <= 500))
        i2, _, _ = vs.pairs_within(x, y, x + 50, y, same=False)
        self.assertGreater(len(i2), len(i))

    def test_outcome_readings(self):
        self.assertEqual(vs.outcome(0.2, (0.556, 0.862)), 'below the data')
        self.assertEqual(vs.outcome(0.7, (0.556, 0.862)), 'within the data')
        self.assertEqual(vs.outcome(0.9, (0.556, 0.862)), 'above the data')
        self.assertEqual(len(vs.COMBINED_READING), 9)
        self.assertTrue(vs.tau_outcome(20.0).startswith('consistent'))
        self.assertEqual(vs.tau_outcome(5.0), 'shorter than the data')
        self.assertEqual(vs.tau_outcome(70.0), 'longer than the data')
        p = vs.placement([0.1, 0.5, 0.7, 0.9], (0.4, 0.8), 0.72)
        self.assertEqual(p['fraction_inside_found_data_range'], 0.5)
        self.assertEqual(p['data_median_percentile_in_model'], 75.0)


class EndToEnd(unittest.TestCase):
    """Runs main() on small fake exports, positions and a fake contract."""

    def test_main_on_fake_data(self):
        rng = np.random.default_rng(3)
        with tempfile.TemporaryDirectory() as tmp:
            tmp = Path(tmp)
            spikes, positions, next_id = [], {}, 1
            shared = ou(40_320, 15.0, rng)
            for pop, short in vs.POPULATIONS.items():
                ids = list(range(next_id, next_id + 5)); next_id += 10
                values = np.vstack([-65 + 3 * (shared + ou(40_320, 15.0, rng)) for _ in ids])
                timing = {'first_sample_ms': 0.0, 'last_sample_ms': 40_319.0, 't_start_ms': 0.0, 't_stop_ms': 40_320.0, 'sample_period_ms': 1.0}
                np.savez_compressed(tmp / f'exported-analog-{short}-voltage_mV.npz', ids=np.array(ids), values=values, timing=json.dumps(timing))
                spikes.append({'population': pop, 'spikes': [{'id': i, 'times_ms': sorted(rng.uniform(0, 40_320, 20).tolist())} for i in ids]})
                positions[pop] = {'ids': ids, 'x_um': [100.0 * k for k in range(5)], 'y_um': [0.0] * 5}
            with gzip.open(tmp / 'exported-spikes.json.gz', 'wt') as fh:
                json.dump(spikes, fh)
            (tmp / 'positions.json').write_text(json.dumps({'populations': positions}))
            digest = lambda p: hashlib.sha256(p.read_bytes()).hexdigest()
            names = [f'exported-analog-{s}-voltage_mV.npz' for s in vs.POPULATIONS.values()] + ['exported-spikes.json.gz', 'positions.json']
            contract = {'model_inputs': {n: digest(tmp / n) for n in names}, 'data_targets': {
                'yu_ferster_2010': {'fig4A_blank_found_range': [0.403, 0.908], 'fig4A_blank_median_found': 0.722,
                                    'fig4B_blank_found_range': [0.189, 0.682], 'fig4B_blank_median_found': 0.332},
                'fig4A_blank_bounds_p25_low_p75_high': [0.556, 0.862], 'fig4B_blank_bounds_p25_low_p75_high': [0.111, 0.562],
                'yu_ferster_example_complex_pair': {'peak': 0.66}, 'yu_ferster_simple_complex_pair': {'peak': 0.4},
                'azouz_gray_1999': {'tau_spontaneous_ms_mean': 38, 'dispersion_ms': 26}}}
            (tmp / 'contract.json').write_text(json.dumps(contract))
            vs.main(['--analysis', str(tmp), '--positions', str(tmp / 'positions.json'), '--output', str(tmp / 'out'),
                     '--contract', str(tmp / 'contract.json')])
            res = json.loads((tmp / 'out' / 'vm-synchrony-results.json').read_text())
            primary = res['groups'][vs.PRIMARY]
            self.assertEqual(primary['pairs'], 10)                       # 5 neurons in a 400 um row: all 10 pairs
            self.assertGreater(primary['peak']['median'], 0.3)           # shared component
            self.assertIn(primary['declared_outcomes']['combined_reading'], vs.COMBINED_READING.values())
            self.assertIn('fraction_inside_found_data_range', primary['placement']['unfiltered_peak'])
            self.assertEqual(res['groups']['L4E-L23E']['pairs'], 25 - 0)   # cross-population: all 5 x 5 within 500 um
            self.assertIsNotNone(res['tau']['declared_outcome'])
            self.assertEqual(res['provenance']['contract_sha256'], digest(tmp / 'contract.json'))
            # a modified input is rejected
            (tmp / 'positions.json').write_text(json.dumps({'populations': positions}) + ' ')
            with self.assertRaises(SystemExit):
                vs.main(['--analysis', str(tmp), '--positions', str(tmp / 'positions.json'), '--output', str(tmp / 'out2'),
                         '--contract', str(tmp / 'contract.json')])


if __name__ == '__main__':
    unittest.main()
