"""Synthetic tests of fluctuations.py:  python3 -m unittest -v test_fluctuations"""
import unittest
import numpy as np
import fluctuations as f


def doubly_stochastic(rate_hz, cv, n_units, seconds, bin_s, rng, shared=True):
    """Spike trains whose rate is constant within each bin and lognormally modulated across bins, by one shared
    factor (shared=True) or independently per unit. The latent-rate CV^2 of the pooled count is cv^2 when shared."""
    sigma2 = np.log(1 + cv ** 2)
    n_bins = int(round(seconds / bin_s))
    trains = [[] for _ in range(n_units)]
    shared_factor = np.exp(rng.normal(-sigma2 / 2, np.sqrt(sigma2), n_bins))
    for u in range(n_units):
        factor = shared_factor if shared else np.exp(rng.normal(-sigma2 / 2, np.sqrt(sigma2), n_bins))
        counts = rng.poisson(rate_hz * bin_s * factor)
        trains[u] = np.concatenate([b * bin_s + rng.uniform(0, bin_s, c) for b, c in enumerate(counts)])
    return trains


def thin(trains, p, rng):
    return [t[rng.random(len(t)) < p] for t in trains]


class Fluctuations(unittest.TestCase):
    def setUp(self):
        self.rng = np.random.default_rng(0)
        self.starts = np.arange(400.0)

    def test_poisson_has_no_excess(self):
        trains = [np.sort(self.rng.uniform(0, 400, 4000)) for _ in range(20)]
        v = f.excess_cv2(f.population_counts(trains, self.starts, 0.1))
        self.assertLess(abs(v), 0.01)

    def test_recovers_known_latent_cv2(self):
        trains = doubly_stochastic(5.0, 0.5, 20, 400, 0.1, self.rng)
        v = f.excess_cv2(f.population_counts(trains, self.starts, 0.1))
        self.assertAlmostEqual(v, 0.25, delta=0.03)

    def test_thinning_invariance(self):
        trains = doubly_stochastic(5.0, 0.5, 20, 400, 0.1, self.rng)
        full = f.excess_cv2(f.population_counts(trains, self.starts, 0.1))
        for p in (0.5, 0.2):
            thinned = f.excess_cv2(f.population_counts(thin(trains, p, self.rng), self.starts, 0.1))
            self.assertAlmostEqual(thinned, full, delta=0.04)
        cov_full, _ = f.mean_normalised_covariance(np.array([f.segment_counts(t, self.starts, 0.1).ravel() for t in trains]))
        mixed = [t[self.rng.random(len(t)) < p] for t, p in zip(trains, np.linspace(0.15, 0.9, 20))]   # unit-specific deletion
        cov_thin, pairs = f.mean_normalised_covariance(np.array([f.segment_counts(t, self.starts, 0.1).ravel() for t in mixed]))
        self.assertEqual(pairs, 190)
        self.assertAlmostEqual(cov_thin, cov_full, delta=0.03)
        self.assertAlmostEqual(cov_full, 0.25, delta=0.03)

    def test_independent_fluctuations_do_not_count_as_shared(self):
        trains = doubly_stochastic(5.0, 0.5, 20, 400, 0.1, self.rng, shared=False)
        cov, _ = f.mean_normalised_covariance(np.array([f.segment_counts(t, self.starts, 0.1).ravel() for t in trains]))
        self.assertLess(abs(cov), 0.02)
        self.assertLess(f.excess_cv2(f.population_counts(trains, self.starts, 0.1)), 0.03)   # 0.25 / 20 units

    def test_within_segment_measure_ignores_drift_and_site_changes(self):
        units = doubly_stochastic(5.0, 0.5, 40, 400, 0.1, self.rng)           # one shared latent process
        trains = units[:20]
        seg = f.population_counts(trains, self.starts, 0.1)
        self.assertAlmostEqual(f.within_segment_excess_cv2(seg), 0.25, delta=0.04)
        # the other 20 units are recorded only in the second half (a site change); the first 20 drift slowly
        late = [t[t >= 200] for t in units[20:]]
        drift = [t[self.rng.random(len(t)) < 0.4 + 0.6 * t / 400] for t in trains]
        seg2 = f.population_counts(drift + late, self.starts, 0.1)
        self.assertGreater(f.excess_cv2(seg2), 0.35)                       # the whole-session measure is inflated
        self.assertAlmostEqual(f.within_segment_excess_cv2(seg2), 0.25, delta=0.05)
        thinned = f.population_counts(thin(trains, 0.3, self.rng), self.starts, 0.1)
        self.assertAlmostEqual(f.within_segment_excess_cv2(thinned), f.within_segment_excess_cv2(seg), delta=0.05)
        poisson = f.population_counts([np.sort(self.rng.uniform(0, 400, 4000)) for _ in range(20)], self.starts, 0.1)
        self.assertLess(abs(f.within_segment_excess_cv2(poisson)), 0.01)

    def test_within_segment_covariance(self):
        trains = doubly_stochastic(5.0, 0.5, 12, 400, 0.1, self.rng)
        by_unit = np.array([f.segment_counts(t, self.starts, 0.1) for t in trains])
        cov, pairs = f.within_segment_normalised_covariance(by_unit)
        self.assertEqual(pairs, 66)
        self.assertAlmostEqual(cov, 0.25, delta=0.04)
        indep = doubly_stochastic(5.0, 0.5, 12, 400, 0.1, self.rng, shared=False)
        cov0, _ = f.within_segment_normalised_covariance(np.array([f.segment_counts(t, self.starts, 0.1) for t in indep]))
        self.assertLess(abs(cov0), 0.02)

    def test_pairwise_measure_ignores_private_variability_and_unit_count(self):
        rng = np.random.default_rng(5)
        def units(n, rate_hz, shared_cv, private_cv, seconds=400):
            bins = int(seconds / 0.1)
            s2, p2 = np.log(1 + shared_cv ** 2), np.log(1 + private_cv ** 2)
            shared = np.exp(rng.normal(-s2 / 2, np.sqrt(s2), bins))
            out = []
            for _ in range(n):
                private = np.exp(rng.normal(-p2 / 2, np.sqrt(p2), bins))
                counts = rng.poisson(rate_hz * 0.1 * shared * private)
                out.append(np.concatenate([b * 0.1 + rng.uniform(0, 0.1, k) for b, k in enumerate(counts)]))
            return out
        starts = np.arange(400.0)
        few = units(20, 1.0, np.sqrt(0.05), np.sqrt(2.0))                  # data-like: 20 sites at 1 Hz, private CV^2 2
        many = units(400, 3.0, np.sqrt(0.05), 0.0)                         # model-like: many units, no private wander
        by = lambda tr: np.array([f.segment_counts(x, starts, 0.1) for x in tr])
        self.assertAlmostEqual(f.within_segment_pairwise(by(few)), 0.05, delta=0.03)
        self.assertAlmostEqual(f.within_segment_pairwise(by(many)), 0.05, delta=0.01)
        pooled_few = f.within_segment_excess_cv2(f.population_counts(few, starts, 0.1))
        self.assertGreater(pooled_few, 0.1)                                # the pooled measure counts private variance
        uneven = [x[rng.random(len(x)) < p] for x, p in zip(many, np.linspace(0.1, 1.0, 400))]
        self.assertAlmostEqual(f.within_segment_pairwise(by(uneven)), 0.05, delta=0.012)
        indep = units(40, 3.0, 0.0, 1.0)
        self.assertLess(abs(f.within_segment_pairwise(by(indep))), 0.01)

    def test_bootstrap_shuffle_and_local_draws(self):
        trains = doubly_stochastic(5.0, 0.5, 10, 400, 0.1, self.rng)
        by = np.array([f.segment_counts(x, self.starts, 0.1) for x in trains])
        boot = f.bootstrap_segments(f.within_segment_pairwise, by, 200, np.random.default_rng(2))
        lo, hi = np.percentile(boot, [2.5, 97.5])
        self.assertTrue(lo < 0.25 < hi)
        null = f.within_segment_pairwise(f.shuffle_within_segments(by, np.random.default_rng(3)))
        self.assertLess(abs(null), 0.02)
        self.assertTrue(np.array_equal(f.shuffle_within_segments(by, np.random.default_rng(3)).sum(axis=2), by.sum(axis=2)))
        idx = f.local_draw_indices(np.array([0, 1, 2, 10, 11, 12, 50, 51]), 3, 20, np.random.default_rng(4))
        for i in idx:
            self.assertEqual(len(i), 3)
            self.assertLessEqual(np.ptp(np.array([0, 1, 2, 10, 11, 12, 50, 51])[i]), 40)

    def test_cross_site_coincidences(self):
        rng = np.random.default_rng(7)
        trains = [np.sort(rng.uniform(0, 1000, 1000)) for _ in range(10)]          # 1 Hz per site, independent
        masks, ratio, flagged, events = f.cross_site_coincidences(trains)
        self.assertAlmostEqual(ratio, 1.0, delta=0.5)
        self.assertLess(flagged, 0.001)
        comod = doubly_stochastic(2.0, 1.2, 10, 400, 0.1, rng)                       # data-like rates fluctuating together at 100 ms
        _, ratio_c, flagged_c, _ = f.cross_site_coincidences(comod)
        self.assertAlmostEqual(ratio_c, 1.0, delta=0.3)
        self.assertLess(flagged_c, 0.002)
        artifacts = np.sort(rng.uniform(0, 1000, 300))                              # common-mode events on every site
        dirty = [np.sort(np.concatenate([x, artifacts + rng.uniform(-5e-5, 5e-5, 300)])) for x in trains]
        masks, ratio_d, flagged_d, events_d = f.cross_site_coincidences(dirty)
        self.assertGreater(ratio_d, 20)
        self.assertGreater(flagged_d, 0.2)
        self.assertAlmostEqual(events_d, 300, delta=15)
        chain = [np.array([10.0]), np.array([10.00015]), np.array([10.0003])]      # a chained event: all copies are marked
        m_chain, _, _, ev = f.cross_site_coincidences(chain + [np.array([500.0])])
        self.assertEqual([bool(x[0]) for x in m_chain[:3]], [True, True, True])
        self.assertEqual(ev, 1)
        quant = [np.round(np.sort(rng.uniform(3000, 6000, 6000)), 4) for _ in range(20)]   # 0.1 ms resolution, independent
        self.assertAlmostEqual(f.cross_site_coincidences(quant)[1], 1.0, delta=0.12)
        cleaned = [x[~m] for x, m in zip(dirty, masks)]
        self.assertTrue(all(abs(len(c) - len(x)) <= 5 for c, x in zip(cleaned, trains)))
        starts = np.arange(1000.0)
        by = lambda tr: np.array([f.segment_counts(x, starts, 0.1) for x in tr])
        self.assertGreater(f.within_segment_pairwise(by(dirty)), 0.1)                # artifacts inflate the shared measure
        self.assertLess(abs(f.within_segment_pairwise(by(cleaned))), 0.05)

    def test_segments_and_bins(self):
        c = f.segment_counts([0.05, 0.15, 0.95, 1.0, 2.5, 3.99], [0.0, 1.0, 3.0], 0.1)
        self.assertEqual(c.shape, (3, 10))
        self.assertEqual(c.sum(), 5)                 # 3 + 1 + 1: 2.5 lies in no segment
        self.assertEqual(c[0, 0], 1)
        self.assertEqual(c[1, 0], 1)                 # 1.0 starts the second segment
        self.assertEqual(c[2, 9], 1)
        with self.assertRaises(ValueError):
            f.bin_edges([0.0], 0.3)

    def test_resampling_spread(self):
        trains = doubly_stochastic(5.0, 0.5, 20, 400, 0.1, self.rng)
        seg = f.population_counts(trains, self.starts, 0.1)
        draws = f.resampled_cv2(seg, 40, 300, np.random.default_rng(1))
        self.assertEqual(len(draws), 300)
        self.assertAlmostEqual(float(np.median(draws)), 0.25, delta=0.05)
        self.assertGreater(np.percentile(draws, 97.5) - np.percentile(draws, 2.5), 0.03)
        self.assertEqual(len(f.resampled_cv2(seg[:10], 40, 5, np.random.default_rng(1))), 0)


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