"""
Tests for LocalEmbeddingManager thread safety and cache directory utilities.

These tests verify that embedding initialization is thread-safe
and that the cache directory utility returns correct paths.
"""

import os
import tempfile
import threading
from unittest.mock import MagicMock, patch


class TestEmbeddingThreadSafety:
    """Tests that embedding initialization is thread-safe."""

    def test_concurrent_embedding_access_initializes_once(self):
        """Multiple threads accessing .embeddings should only init once."""
        from local_deep_research.web_search_engines.engines.local_embedding_manager import (
            LocalEmbeddingManager,
        )

        manager = LocalEmbeddingManager(
            embedding_model="test-model",
        )

        # Track how many times _initialize_embeddings is called
        init_count = 0
        init_lock = threading.Lock()
        mock_embeddings = MagicMock()

        def counting_init():
            nonlocal init_count
            with init_lock:
                init_count += 1
            # Simulate slow initialization to widen race window
            import time

            time.sleep(0.1)
            return mock_embeddings

        manager._initialize_embeddings = counting_init

        # Access embeddings from multiple threads concurrently
        results = []
        errors = []

        def access_embeddings():
            try:
                emb = manager.embeddings
                results.append(emb)
            except Exception as e:
                errors.append(e)

        threads = [threading.Thread(target=access_embeddings) for _ in range(4)]
        for t in threads:
            t.start()
        for t in threads:
            t.join()

        assert not errors, f"Threads raised errors: {errors}"
        assert init_count == 1, (
            f"_initialize_embeddings called {init_count} times, expected 1"
        )
        # All threads should get the same instance
        assert all(r is mock_embeddings for r in results)


class TestGetCacheDirectory:
    """Tests for get_cache_directory function."""

    def test_get_cache_directory_returns_absolute_path(self):
        """get_cache_directory should return an absolute path."""
        from local_deep_research.config.paths import get_cache_directory

        cache_dir = get_cache_directory()
        assert cache_dir.is_absolute()

    def test_get_cache_directory_respects_ldr_data_dir(self):
        """get_cache_directory should respect LDR_DATA_DIR env var."""
        with tempfile.TemporaryDirectory() as temp_dir:
            with patch.dict(os.environ, {"LDR_DATA_DIR": temp_dir}):
                from local_deep_research.config.paths import (
                    get_cache_directory,
                )

                cache_dir = get_cache_directory()

                # Should be under the LDR_DATA_DIR
                assert str(cache_dir).startswith(temp_dir)
                assert cache_dir.name == "cache"
