"""Tests for Compressed Context Protocol."""

import sys
from pathlib import Path

import pytest

sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "scripts"))
from compressed_context import (
    compress_ultra, compress_medium, compress_light,
    compress, compress_with_stats,
    DECOMPRESS_INSTRUCTIONS,
)


SAMPLE_BIO = (
    "Alex is the CTO of ExampleCorp and founder of DataPlatform. "
    "He has 13+ years of crypto quantitative trading experience. "
    "He is based in Los Gatos, CA with offices in Shanghai and Taipei."
)

SAMPLE_TECH = (
    "The infrastructure uses Kubernetes for container orchestration "
    "with continuous integration and deployment pipelines. "
    "The application architecture includes distributed database "
    "systems and monitoring dashboards for production environments."
)


class TestCompressUltra:
    def test_reduces_length(self):
        result = compress_ultra(SAMPLE_BIO)
        assert len(result) < len(SAMPLE_BIO)

    def test_preserves_names(self):
        result = compress_ultra(SAMPLE_BIO)
        assert "Alex" in result
        assert "Alex" in result
        assert "ExampleCorp" in result

    def test_abbreviates(self):
        result = compress_ultra(SAMPLE_TECH)
        # Should use abbreviations
        assert "k8s" in result or "infra" in result or len(result) < len(SAMPLE_TECH) * 0.8

    def test_empty(self):
        assert compress_ultra("") == ""

    def test_removes_fillers(self):
        text = "He has extensive experience. In addition, he is skilled."
        result = compress_ultra(text)
        assert "In addition" not in result


class TestCompressMedium:
    def test_less_aggressive(self):
        ultra = compress_ultra(SAMPLE_BIO)
        medium = compress_medium(SAMPLE_BIO)
        # Medium should be longer than ultra (less aggressive)
        assert len(medium) >= len(ultra)

    def test_reduces_length(self):
        result = compress_medium(SAMPLE_TECH)
        assert len(result) < len(SAMPLE_TECH)


class TestCompressLight:
    def test_minimal_changes(self):
        text = "Simple text with no issues"
        assert compress_light(text) == text

    def test_cleanup(self):
        text = "Extra  spaces  here\n\n\n\nToo many lines"
        result = compress_light(text)
        assert "  " not in result.replace("  ", " ")  # might still have some
        assert "\n\n\n" not in result


class TestCompress:
    def test_returns_dict(self):
        result = compress(SAMPLE_BIO, "ultra")
        assert "compressed" in result
        assert "instructions" in result
        assert result["level"] == "ultra"

    def test_all_levels(self):
        for level in ["ultra", "medium", "light"]:
            result = compress(SAMPLE_BIO, level)
            assert result["level"] == level
            assert len(result["compressed"]) > 0
            assert len(result["instructions"]) > 0

    def test_invalid_level(self):
        with pytest.raises(ValueError):
            compress(SAMPLE_BIO, "extreme")

    def test_instructions_exist(self):
        for level in ["ultra", "medium", "light"]:
            assert level in DECOMPRESS_INSTRUCTIONS


class TestCompressWithStats:
    def test_basic(self):
        stats = compress_with_stats(SAMPLE_BIO, "ultra")
        assert stats["original_tokens"] > 0
        assert stats["compressed_tokens"] > 0
        assert stats["compressed_tokens"] < stats["original_tokens"]
        # Note: reduction_pct includes instruction overhead so may be negative for short texts
        assert "instructions" in stats

    def test_all_levels(self):
        for level in ["ultra", "medium", "light"]:
            stats = compress_with_stats(SAMPLE_BIO, level)
            assert stats["original_tokens"] > 0
            assert isinstance(stats["reduction_pct"], float)

    def test_empty(self):
        stats = compress_with_stats("", "ultra")
        assert stats["original_tokens"] == 0

    def test_unicode(self):
        text = "中文内容测试：这是一个很长的中文段落，包含了很多信息。"
        stats = compress_with_stats(text, "ultra")
        assert stats["compressed_tokens"] > 0
        assert "中文" in stats["compressed"]

    def test_real_bio_compression(self):
        """The sample bio should compress the text itself significantly."""
        stats = compress_with_stats(SAMPLE_BIO, "ultra")
        # Compressed text alone should be smaller than original
        assert stats["compressed_tokens"] < stats["original_tokens"]
        # For longer texts, net reduction (including instructions) should be positive
        # For short texts like this, just verify text compression works
        text_reduction = (stats["original_tokens"] - stats["compressed_tokens"]) / stats["original_tokens"] * 100
        assert text_reduction > 5, f"Only {text_reduction:.1f}% text reduction"


class TestCLI:
    def test_file_compress(self, tmp_path):
        """Test that compress works on a file's content."""
        f = tmp_path / "test.md"
        f.write_text(SAMPLE_BIO)
        text = f.read_text()
        stats = compress_with_stats(text, "ultra")
        assert stats["compressed_tokens"] < stats["original_tokens"]