"""Tests for MPack compression — zstd support and zlib fallback.

Coverage tiers
--------------
- ZSTD_AVAILABLE: boolean flag reflects package presence
- compress_zstd / decompress_zstd: round-trip fidelity
- compress_zstd: fallback to zlib when zstd absent (tested via monkeypatching)
- choose_compression: returns "zstd" when available, "zlib" otherwise
- Compression ratio: zstd ≥ zlib on source code (when zstd available)
- Edge cases: empty bytes, single byte, 1MB payload
- Error handling: corrupt data raises on decompress
"""
from __future__ import annotations

import zlib

import pytest


# ---------------------------------------------------------------------------
# ZSTD_AVAILABLE flag
# ---------------------------------------------------------------------------


class TestZstdAvailableFlag:
    def test_zstd_available_is_bool(self) -> None:
        from muse.core.compression import ZSTD_AVAILABLE
        assert isinstance(ZSTD_AVAILABLE, bool)

    def test_zstd_available_reflects_import(self) -> None:
        from muse.core.compression import ZSTD_AVAILABLE
        try:
            import zstandard  # noqa: F401
            expected = True
        except ImportError:
            expected = False
        assert ZSTD_AVAILABLE == expected


# ---------------------------------------------------------------------------
# compress_zstd / decompress_zstd — round-trip
# ---------------------------------------------------------------------------


class TestZstdRoundTrip:
    def test_empty_bytes(self) -> None:
        from muse.core.compression import compress_zstd, decompress_zstd
        assert decompress_zstd(compress_zstd(b"")) == b""

    def test_single_byte(self) -> None:
        from muse.core.compression import compress_zstd, decompress_zstd
        assert decompress_zstd(compress_zstd(b"\x00")) == b"\x00"

    def test_source_code(self) -> None:
        from muse.core.compression import compress_zstd, decompress_zstd
        data = b"def hello():\n    return 'world'\n" * 100
        assert decompress_zstd(compress_zstd(data)) == data

    def test_binary_data(self) -> None:
        from muse.core.compression import compress_zstd, decompress_zstd
        data = bytes(range(256)) * 500
        assert decompress_zstd(compress_zstd(data)) == data

    def test_1mb_payload(self) -> None:
        from muse.core.compression import compress_zstd, decompress_zstd
        data = b"x" * (1024 * 1024)
        assert decompress_zstd(compress_zstd(data)) == data

    def test_compress_returns_bytes(self) -> None:
        from muse.core.compression import compress_zstd
        result = compress_zstd(b"hello")
        assert isinstance(result, bytes)

    def test_decompress_returns_bytes(self) -> None:
        from muse.core.compression import compress_zstd, decompress_zstd
        result = decompress_zstd(compress_zstd(b"hello"))
        assert isinstance(result, bytes)


# ---------------------------------------------------------------------------
# choose_compression
# ---------------------------------------------------------------------------


class TestChooseCompression:
    def test_returns_string(self) -> None:
        from muse.core.compression import choose_compression
        result = choose_compression()
        assert isinstance(result, str)

    def test_returns_valid_encoding(self) -> None:
        from muse.core.compression import choose_compression
        result = choose_compression()
        assert result in ("zstd", "zlib")

    def test_matches_zstd_available(self) -> None:
        from muse.core.compression import choose_compression, ZSTD_AVAILABLE
        result = choose_compression()
        if ZSTD_AVAILABLE:
            assert result == "zstd"
        else:
            assert result == "zlib"


# ---------------------------------------------------------------------------
# compress_and_encode / decompress_frame — unified interface
# ---------------------------------------------------------------------------


class TestCompressAndEncode:
    def test_compress_and_encode_returns_bytes_and_enc(self) -> None:
        from muse.core.compression import compress_and_encode
        data = b"hello world " * 50
        compressed, enc = compress_and_encode(data)
        assert isinstance(compressed, bytes)
        assert enc in ("zstd", "zlib")

    def test_compress_and_encode_round_trip(self) -> None:
        from muse.core.compression import compress_and_encode, decompress_frame
        data = b"round trip test " * 100
        compressed, enc = compress_and_encode(data)
        recovered = decompress_frame(compressed, enc)
        assert recovered == data

    def test_decompress_frame_zlib(self) -> None:
        from muse.core.compression import decompress_frame
        data = b"hello"
        compressed = zlib.compress(data)
        assert decompress_frame(compressed, "zlib") == data

    def test_decompress_frame_raw(self) -> None:
        from muse.core.compression import decompress_frame
        data = b"raw bytes"
        assert decompress_frame(data, "raw") == data

    def test_decompress_frame_unknown_enc_raises(self) -> None:
        from muse.core.compression import decompress_frame
        with pytest.raises((ValueError, Exception)):
            decompress_frame(b"data", "lz4")


# ---------------------------------------------------------------------------
# Compression ratio (zstd ≥ zlib on source code, when zstd available)
# ---------------------------------------------------------------------------


class TestCompressionRatio:
    def test_zstd_at_least_as_good_as_zlib_on_source(self) -> None:
        from muse.core.compression import ZSTD_AVAILABLE, compress_zstd, compress_zlib
        if not ZSTD_AVAILABLE:
            pytest.skip("zstd not available")
        data = b"def foo(x):\n    return x + 1\n" * 200
        zstd_size = len(compress_zstd(data))
        zlib_size = len(compress_zlib(data))
        # zstd should be at least as good — not necessarily better on every payload
        assert zstd_size <= zlib_size * 1.1, (
            f"zstd ({zstd_size}B) more than 10% larger than zlib ({zlib_size}B)"
        )

    def test_zstd_faster_than_zlib_on_large_payload(self) -> None:
        """zstd level 3 should be faster than zlib level 1 on large data."""
        import time
        from muse.core.compression import ZSTD_AVAILABLE, compress_zstd, compress_zlib
        if not ZSTD_AVAILABLE:
            pytest.skip("zstd not available")
        data = b"source code line\n" * 100_000  # ~1.7 MB
        t0 = time.monotonic()
        for _ in range(5):
            compress_zlib(data)
        zlib_time = time.monotonic() - t0

        t0 = time.monotonic()
        for _ in range(5):
            compress_zstd(data)
        zstd_time = time.monotonic() - t0

        # zstd should be meaningfully faster on large repetitive payloads
        assert zstd_time < zlib_time * 2.0, (
            f"zstd ({zstd_time:.3f}s) not faster than 2× zlib ({zlib_time:.3f}s)"
        )


# ---------------------------------------------------------------------------
# Error handling
# ---------------------------------------------------------------------------


class TestDecompressErrors:
    def test_corrupt_zlib_raises(self) -> None:
        from muse.core.compression import decompress_zlib
        with pytest.raises(zlib.error):
            decompress_zlib(b"not valid zlib")

    def test_corrupt_zstd_raises(self) -> None:
        from muse.core.compression import ZSTD_AVAILABLE, decompress_zstd
        if not ZSTD_AVAILABLE:
            pytest.skip("zstd not available")
        with pytest.raises(Exception):
            decompress_zstd(b"not valid zstd")