import pickle
import time
import types

import pytest
import zstandard as zstd

from monday_com_orca_backend.utils.cache import TTLCache


@pytest.mark.parametrize("compress", [False, True])
@pytest.mark.parametrize(
    "value",
    [
        42,
        3.14,
        "hello",
        [1, 2, 3],
        {"a": 1, "b": [2, 3]},
        (x for x in range(3)),  # generator: only fails if compression enabled
    ],
)
def test_cache_set_get(tmp_path, compress, value):
    cache = TTLCache(maxsize=10, ttl=5, compress=compress)
    key = "test"

    if compress and isinstance(value, types.GeneratorType):
        with pytest.raises(TypeError):
            cache[key] = value
        return

    cache[key] = value
    assert cache[key] == value
    assert key in cache
    assert cache.get(key) == value


@pytest.mark.parametrize("compress", [False, True])
def test_cache_eviction(compress):
    cache = TTLCache(maxsize=2, ttl=10, compress=compress)
    cache["a"] = "A"
    cache["b"] = "B"
    cache["c"] = "C"  # should evict "a"
    assert "a" not in cache
    assert "b" in cache
    assert "c" in cache


@pytest.mark.parametrize("compress", [False, True])
def test_cache_ttl_expiration(compress):
    cache = TTLCache(maxsize=2, ttl=0.1, compress=compress)
    cache["x"] = "data"
    time.sleep(0.2)
    assert cache.get("x") is None
    assert "x" not in cache


@pytest.mark.parametrize("compress", [False, True])
def test_overwrite_existing_key(compress):
    cache = TTLCache(maxsize=5, ttl=5, compress=compress)
    cache["k"] = "v1"
    cache["k"] = "v2"
    assert cache["k"] == "v2"


def test_no_compression_objects_equal_bytes():
    """Verify that compressed bytes differ from raw pickled bytes."""
    import pickle

    import zstandard as zstd

    obj = {"x": 1, "y": 2}
    raw = pickle.dumps(obj)
    compressed = zstd.ZstdCompressor().compress(raw)
    assert raw != compressed


def test_compression_roundtrip_identity():
    """Ensure object survives compress + decompress unchanged."""
    obj = {"nested": [1, 2, 3], "val": 42}
    cache = TTLCache(maxsize=1, ttl=10, compress=True)
    cache["obj"] = obj
    assert cache["obj"] == obj


def test_compressed_bytes_differ():
    """Ensure compressed form differs from raw pickle."""
    obj = {"foo": "bar"}
    pickled = pickle.dumps(obj)
    compressed = zstd.ZstdCompressor().compress(pickled)
    assert compressed != pickled
    assert pickle.loads(zstd.ZstdDecompressor().decompress(compressed)) == obj


def test_internal_bytes_in_cache():
    """Ensure compressed data is stored (not raw object)."""
    obj = [1, 2, 3]
    cache = TTLCache(maxsize=1, ttl=5, compress=True)
    cache["x"] = obj
    raw = super(TTLCache, cache).__getitem__("x")
    assert isinstance(raw, bytes)
    assert raw != pickle.dumps(obj)


def test_invalid_decompression():
    """Ensure invalid data raises during decompress."""
    cache = TTLCache(maxsize=1, ttl=5, compress=True)
    bad_data = b"not-zstd-compressed"
    super(TTLCache, cache).__setitem__("bad", bad_data)
    with pytest.raises(zstd.ZstdError):
        _ = cache["bad"]


def test_decompression_not_run_if_disabled():
    """Ensure no decompress if compress=False (raw object returned)."""
    obj = {"x": "y"}
    cache = TTLCache(maxsize=1, ttl=5, compress=False)
    cache["key"] = obj
    assert cache["key"] == obj
    # make sure nothing was pickled/compressed
    assert not isinstance(super(TTLCache, cache).__getitem__("key"), bytes)