"""
tests/test_feedback.py — Tests for feedback loop (no API required)
"""
import sys
import tempfile
from pathlib import Path
import pytest

sys.path.insert(0, str(Path(__file__).parent.parent))

from feedback.diff_engine import DiffEngine
from feedback.pattern_store import PatternStore


class TestDiffEngine:
    def setup_method(self):
        self.engine = DiffEngine()

    def test_identical_texts(self):
        diff = self.engine.compute("hello world", "hello world")
        assert diff.change_ratio == 0.0
        assert diff.additions == []
        assert diff.deletions == []

    def test_added_content(self):
        diff = self.engine.compute("line one", "line one\nline two")
        assert len(diff.additions) > 0
        assert diff.change_ratio > 0

    def test_deleted_content(self):
        diff = self.engine.compute("line one\nline two", "line one")
        assert len(diff.deletions) > 0

    def test_replaced_content(self):
        diff = self.engine.compute("old text here", "new text here")
        assert len(diff.additions) > 0
        assert len(diff.deletions) > 0

    def test_change_ratio_range(self):
        diff = self.engine.compute("aaa", "zzz")
        assert 0.0 <= diff.change_ratio <= 1.0

    def test_large_edit(self):
        original = "Section 1\nContent A\nSection 2\nContent B"
        edited = "Section 1\nContent A Modified\nSection 2\nContent B\nSection 3\nNew content"
        diff = self.engine.compute(original, edited)
        assert diff.change_ratio > 0.05


class TestPatternStore:
    @pytest.fixture
    def store(self):
        with tempfile.TemporaryDirectory() as tmpdir:
            yield PatternStore(db_path=Path(tmpdir) / "test.db")

    def test_save_and_retrieve(self, store):
        pid = store.save_pattern("Always list dates chronologically", "contract")
        patterns = store.get_active_patterns()
        assert len(patterns) == 1
        assert patterns[0][1] == "Always list dates chronologically"

    def test_deactivate_pattern(self, store):
        pid = store.save_pattern("Test pattern", "memo")
        store.deactivate_pattern(pid)
        patterns = store.get_active_patterns()
        assert len(patterns) == 0

    def test_update_pattern(self, store):
        pid = store.save_pattern("Old rule", "contract")
        store.update_pattern(pid, "New improved rule")
        patterns = store.get_active_patterns()
        assert patterns[0][1] == "New improved rule"

    def test_pattern_count(self, store):
        assert store.pattern_count() == 0
        store.save_pattern("Rule 1", "contract")
        store.save_pattern("Rule 2", "memo")
        assert store.pattern_count() == 2

    def test_draft_history(self, store):
        store.save_draft("d1", "Case Fact Summary", "file.pdf", "Draft text here")
        draft = store.get_draft("d1")
        assert draft is not None
        assert draft["draft_type"] == "Case Fact Summary"

    def test_feedback_log(self, store):
        store.log_feedback("d1", "original", "edited", 0.15, "p1")

    def test_filter_by_doc_type(self, store):
        store.save_pattern("Contract rule", "contract")
        store.save_pattern("Memo rule", "memo")
        contract_patterns = store.get_active_patterns(doc_type="contract")
        assert len(contract_patterns) == 1
        assert "Contract" in contract_patterns[0][1]

    def test_get_all_patterns(self, store):
        store.save_pattern("Rule A", "contract")
        store.save_pattern("Rule B", "memo")
        all_p = store.get_all_patterns()
        assert len(all_p) == 2
        assert "pattern" in all_p[0]