import numpy as np

from suite19_encoders import ModernNCAEncoder


def _normalize(x):
    x = np.asarray(x, np.float32)
    return x / np.maximum(
        np.linalg.norm(x, axis=1, keepdims=True),
        1e-8,
    )


def _dense_reference(
    q,
    m,
    y,
    *,
    temperature=0.1,
    k=32,
    exclude_self=False,
):
    sim = q @ m.T

    if (
        exclude_self
        and len(q) == len(m)
        and np.array_equal(q, m)
    ):
        np.fill_diagonal(sim, -np.inf)

    kk = min(
        int(k),
        len(m) - int(bool(exclude_self)),
    )

    order = np.argsort(-sim, axis=1)[:, :kk]
    val = np.take_along_axis(sim, order, axis=1)

    vmax = val.max(axis=1, keepdims=True)
    w = np.exp(
        ((val - vmax) / temperature).astype(np.float64)
    )
    w /= w.sum(axis=1, keepdims=True)

    p = np.sum(w * y[order], axis=1)

    return p.astype(np.float32), order


def test_streaming_topk_matches_dense():
    rng = np.random.default_rng(123)

    q = _normalize(rng.normal(size=(37, 16)))
    m = _normalize(rng.normal(size=(113, 16)))
    y = rng.integers(0, 2, size=len(m))

    expected, _ = _dense_reference(
        q,
        m,
        y,
        temperature=.10,
        k=17,
    )

    actual = ModernNCAEncoder.soft_neighbor_from_embeddings(
        q,
        m,
        y,
        temperature=.10,
        k=17,
        chunk_size=7,
        memory_chunk_size=19,
    )

    np.testing.assert_allclose(
        actual,
        expected,
        rtol=1e-6,
        atol=1e-6,
    )


def test_streaming_indices_match_dense():
    rng = np.random.default_rng(456)

    q = _normalize(rng.normal(size=(31, 12)))
    m = _normalize(rng.normal(size=(97, 12)))
    y = rng.integers(0, 2, size=len(m))

    expected_p, expected_i = _dense_reference(
        q,
        m,
        y,
        temperature=.2,
        k=11,
    )

    actual_p, actual_i = (
        ModernNCAEncoder.soft_neighbor_from_embeddings(
            q,
            m,
            y,
            temperature=.2,
            k=11,
            chunk_size=8,
            memory_chunk_size=13,
            return_indices=True,
        )
    )

    np.testing.assert_allclose(
        actual_p,
        expected_p,
        rtol=1e-6,
        atol=1e-6,
    )

    np.testing.assert_array_equal(
        actual_i,
        expected_i,
    )


def test_streaming_self_exclusion_matches_dense():
    rng = np.random.default_rng(789)

    z = _normalize(rng.normal(size=(83, 10)))
    y = rng.integers(0, 2, size=len(z))

    expected, _ = _dense_reference(
        z,
        z,
        y,
        temperature=.1,
        k=15,
        exclude_self=True,
    )

    actual = ModernNCAEncoder.soft_neighbor_from_embeddings(
        z,
        z,
        y,
        temperature=.1,
        k=15,
        exclude_self=True,
        chunk_size=9,
        memory_chunk_size=17,
    )

    np.testing.assert_allclose(
        actual,
        expected,
        rtol=1e-6,
        atol=1e-6,
    )


def test_large_memory_retrieval_stays_finite():
    rng = np.random.default_rng(42)

    q = _normalize(
        rng.normal(size=(512, 32))
    )

    m = _normalize(
        rng.normal(size=(100_000, 32))
    )

    y = rng.integers(
        0,
        2,
        size=len(m),
    )

    p = ModernNCAEncoder.soft_neighbor_from_embeddings(
        q,
        m,
        y,
        temperature=.1,
        k=32,
        chunk_size=64,
        memory_chunk_size=2048,
    )

    assert p.shape == (len(q),)
    assert np.isfinite(p).all()
    assert ((p >= 0) & (p <= 1)).all()