"""Tests for Git store functionality."""

import json
from datetime import datetime

from pydantic import HttpUrl

from thicket.core.git_store import GitStore
from thicket.models import AtomEntry, DuplicateMap, UserMetadata


class TestGitStore:
    """Test the GitStore class."""

    def test_init_new_repo(self, temp_dir):
        """Test initializing a new Git repository."""
        repo_path = temp_dir / "test_repo"
        store = GitStore(repo_path)

        assert store.repo_path == repo_path
        assert store.repo is not None
        assert repo_path.exists()
        assert (repo_path / ".git").exists()
        assert (repo_path / "index.json").exists()
        assert (repo_path / "duplicates.json").exists()

    def test_init_existing_repo(self, temp_dir):
        """Test initializing with existing repository."""
        repo_path = temp_dir / "test_repo"

        # Create first store
        store1 = GitStore(repo_path)
        store1.add_user("testuser", display_name="Test User")

        # Create second store pointing to same repo
        store2 = GitStore(repo_path)
        user = store2.get_user("testuser")

        assert user is not None
        assert user.username == "testuser"
        assert user.display_name == "Test User"

    def test_add_user(self, temp_dir):
        """Test adding a user to the Git store."""
        store = GitStore(temp_dir / "test_repo")

        user = store.add_user(
            username="testuser",
            display_name="Test User",
            email="test@example.com",
            homepage="https://example.com",
            icon="https://example.com/icon.png",
            feeds=["https://example.com/feed.xml"],
        )

        assert isinstance(user, UserMetadata)
        assert user.username == "testuser"
        assert user.display_name == "Test User"
        assert user.email == "test@example.com"
        assert user.homepage == "https://example.com"
        assert user.icon == "https://example.com/icon.png"
        assert user.feeds == ["https://example.com/feed.xml"]
        assert user.directory == "testuser"

        # Check that user directory was created
        user_dir = store.repo_path / "testuser"
        assert user_dir.exists()

        # Check user exists in index
        stored_user = store.get_user("testuser")
        assert stored_user is not None
        assert stored_user.username == "testuser"
        assert stored_user.display_name == "Test User"

    def test_get_user(self, temp_dir):
        """Test getting user metadata."""
        store = GitStore(temp_dir / "test_repo")

        # Add user
        store.add_user("testuser", display_name="Test User")

        # Get user
        user = store.get_user("testuser")
        assert user is not None
        assert user.username == "testuser"
        assert user.display_name == "Test User"

        # Try to get non-existent user
        non_user = store.get_user("nonexistent")
        assert non_user is None

    def test_store_entry(self, temp_dir):
        """Test storing an entry."""
        store = GitStore(temp_dir / "test_repo")

        # Add user first
        store.add_user("testuser")

        # Create test entry
        entry = AtomEntry(
            id="https://example.com/entry/1",
            title="Test Entry",
            link=HttpUrl("https://example.com/entry/1"),
            updated=datetime.now(),
            summary="Test entry summary",
            content="<p>Test content</p>",
        )

        # Store entry
        result = store.store_entry("testuser", entry)
        assert result is True

        # Check that entry file was created
        user_dir = store.repo_path / "testuser"
        entry_files = list(user_dir.glob("*.json"))
        entry_files = [f for f in entry_files if f.name != "metadata.json"]
        assert len(entry_files) == 1

        # Check entry content
        with open(entry_files[0]) as f:
            stored_entry = json.load(f)
        assert stored_entry["title"] == "Test Entry"
        assert stored_entry["id"] == "https://example.com/entry/1"

    def test_get_entry(self, temp_dir):
        """Test retrieving an entry."""
        store = GitStore(temp_dir / "test_repo")

        # Add user and entry
        store.add_user("testuser")
        entry = AtomEntry(
            id="https://example.com/entry/1",
            title="Test Entry",
            link=HttpUrl("https://example.com/entry/1"),
            updated=datetime.now(),
        )
        store.store_entry("testuser", entry)

        # Get entry
        retrieved = store.get_entry("testuser", "https://example.com/entry/1")
        assert retrieved is not None
        assert retrieved.title == "Test Entry"
        assert retrieved.id == "https://example.com/entry/1"

        # Try to get non-existent entry
        non_entry = store.get_entry("testuser", "https://example.com/nonexistent")
        assert non_entry is None

    def test_list_entries(self, temp_dir):
        """Test listing entries for a user."""
        store = GitStore(temp_dir / "test_repo")

        # Add user
        store.add_user("testuser")

        # Add multiple entries
        for i in range(3):
            entry = AtomEntry(
                id=f"https://example.com/entry/{i}",
                title=f"Test Entry {i}",
                link=HttpUrl(f"https://example.com/entry/{i}"),
                updated=datetime.now(),
            )
            store.store_entry("testuser", entry)

        # List all entries
        entries = store.list_entries("testuser")
        assert len(entries) == 3

        # List with limit
        limited = store.list_entries("testuser", limit=2)
        assert len(limited) == 2

        # List for non-existent user
        none_entries = store.list_entries("nonexistent")
        assert len(none_entries) == 0

    def test_duplicates(self, temp_dir):
        """Test duplicate management."""
        store = GitStore(temp_dir / "test_repo")

        # Get initial duplicates (should be empty)
        duplicates = store.get_duplicates()
        assert isinstance(duplicates, DuplicateMap)
        assert len(duplicates.duplicates) == 0

        # Add duplicate
        store.add_duplicate("https://example.com/dup", "https://example.com/canonical")

        # Check duplicate was added
        duplicates = store.get_duplicates()
        assert len(duplicates.duplicates) == 1
        assert duplicates.is_duplicate("https://example.com/dup")
        assert (
            duplicates.get_canonical("https://example.com/dup")
            == "https://example.com/canonical"
        )

        # Remove duplicate
        result = store.remove_duplicate("https://example.com/dup")
        assert result is True

        # Check duplicate was removed
        duplicates = store.get_duplicates()
        assert len(duplicates.duplicates) == 0
        assert not duplicates.is_duplicate("https://example.com/dup")

    def test_search_entries(self, temp_dir):
        """Test searching entries."""
        store = GitStore(temp_dir / "test_repo")

        # Add user
        store.add_user("testuser")

        # Add entries with different content
        entries_data = [
            ("Test Python Programming", "Learning Python basics"),
            ("JavaScript Tutorial", "Advanced JavaScript concepts"),
            ("Python Web Development", "Building web apps with Python"),
        ]

        for title, summary in entries_data:
            entry = AtomEntry(
                id=f"https://example.com/entry/{title.lower().replace(' ', '-')}",
                title=title,
                link=HttpUrl(
                    f"https://example.com/entry/{title.lower().replace(' ', '-')}"
                ),
                updated=datetime.now(),
                summary=summary,
            )
            store.store_entry("testuser", entry)

        # Search for Python entries
        results = store.search_entries("Python")
        assert len(results) == 2

        # Search for specific user
        results = store.search_entries("Python", username="testuser")
        assert len(results) == 2

        # Search with limit
        results = store.search_entries("Python", limit=1)
        assert len(results) == 1

        # Search for non-existent term
        results = store.search_entries("NonExistent")
        assert len(results) == 0

    def test_get_stats(self, temp_dir):
        """Test getting repository statistics."""
        store = GitStore(temp_dir / "test_repo")

        # Get initial stats
        stats = store.get_stats()
        assert stats["total_users"] == 0
        assert stats["total_entries"] == 0
        assert stats["total_duplicates"] == 0

        # Add user and entries
        store.add_user("testuser")
        for i in range(3):
            entry = AtomEntry(
                id=f"https://example.com/entry/{i}",
                title=f"Test Entry {i}",
                link=HttpUrl(f"https://example.com/entry/{i}"),
                updated=datetime.now(),
            )
            store.store_entry("testuser", entry)

        # Add duplicate
        store.add_duplicate("https://example.com/dup", "https://example.com/canonical")

        # Get updated stats
        stats = store.get_stats()
        assert stats["total_users"] == 1
        assert stats["total_entries"] == 3
        assert stats["total_duplicates"] == 1
        assert "last_updated" in stats
        assert "repository_size" in stats