"""Tests for ProjectResolver - unified project resolution logic."""

import pytest

from basic_memory.project_resolver import (
    ProjectResolver,
    ResolvedProject,
    ResolutionMode,
)


class TestProjectResolver:
    """Test ProjectResolver class."""

    def test_env_constraint_has_highest_priority(self, monkeypatch):
        """Environment constraint should win over explicit/default."""
        monkeypatch.setenv("BASIC_MEMORY_MCP_PROJECT", "constrained-project")
        resolver = ProjectResolver.from_env(default_project="default-project")

        result = resolver.resolve(project="explicit-project")

        assert result.project == "constrained-project"
        assert result.mode == ResolutionMode.ENV_CONSTRAINT
        assert result.is_resolved is True

    def test_explicit_project_has_second_priority(self):
        """Explicit project parameter should override default."""
        resolver = ProjectResolver(default_project="default-project")

        result = resolver.resolve(project="explicit-project")

        assert result.project == "explicit-project"
        assert result.mode == ResolutionMode.EXPLICIT

    def test_default_project_is_used_as_fallback(self):
        """Default project should be used when explicit is missing."""
        resolver = ProjectResolver(default_project="my-default")

        result = resolver.resolve(project=None)

        assert result.project == "my-default"
        assert result.mode == ResolutionMode.DEFAULT

    def test_no_resolution_when_no_default_and_no_discovery(self):
        """Without explicit/default/discovery, resolution should return NONE."""
        resolver = ProjectResolver(default_project=None)

        result = resolver.resolve(project=None)

        assert result.project is None
        assert result.mode == ResolutionMode.NONE
        assert result.is_resolved is False

    def test_discovery_resolution_when_allowed(self):
        """Discovery mode should return DISCOVERY when allowed."""
        resolver = ProjectResolver(default_project=None)

        result = resolver.resolve(project=None, allow_discovery=True)

        assert result.project is None
        assert result.mode == ResolutionMode.DISCOVERY
        assert result.is_discovery_mode is True

    def test_require_project_success(self):
        """require_project returns result when project resolves."""
        resolver = ProjectResolver(default_project="required-project")

        result = resolver.require_project()

        assert result.project == "required-project"
        assert result.is_resolved is True

    def test_require_project_raises_on_failure(self):
        """require_project raises ValueError when project cannot resolve."""
        resolver = ProjectResolver(default_project=None)

        with pytest.raises(ValueError, match="No project specified"):
            resolver.require_project()

    def test_require_project_custom_error_message(self):
        """require_project uses custom error message."""
        resolver = ProjectResolver(default_project=None)

        with pytest.raises(ValueError, match="Custom error message"):
            resolver.require_project(error_message="Custom error message")

    def test_from_env_without_env_var(self, monkeypatch):
        """from_env without BASIC_MEMORY_MCP_PROJECT set."""
        monkeypatch.delenv("BASIC_MEMORY_MCP_PROJECT", raising=False)
        resolver = ProjectResolver.from_env(default_project="test")

        assert resolver.constrained_project is None
        result = resolver.resolve(project="explicit")
        assert result.mode == ResolutionMode.EXPLICIT

    def test_from_env_with_env_var(self, monkeypatch):
        """from_env with BASIC_MEMORY_MCP_PROJECT set."""
        monkeypatch.setenv("BASIC_MEMORY_MCP_PROJECT", "env-project")
        resolver = ProjectResolver.from_env()

        assert resolver.constrained_project == "env-project"


class TestResolvedProject:
    """Test ResolvedProject dataclass."""

    def test_is_resolved_true(self):
        """is_resolved returns True when project is set."""
        result = ResolvedProject(
            project="test",
            mode=ResolutionMode.EXPLICIT,
            reason="test",
        )
        assert result.is_resolved is True

    def test_is_resolved_false(self):
        """is_resolved returns False when project is None."""
        result = ResolvedProject(
            project=None,
            mode=ResolutionMode.NONE,
            reason="test",
        )
        assert result.is_resolved is False

    def test_is_discovery_mode_discovery(self):
        """is_discovery_mode is True for DISCOVERY."""
        result = ResolvedProject(
            project=None,
            mode=ResolutionMode.DISCOVERY,
            reason="test",
        )
        assert result.is_discovery_mode is True

    def test_is_discovery_mode_none(self):
        """is_discovery_mode is True for NONE with no project."""
        result = ResolvedProject(
            project=None,
            mode=ResolutionMode.NONE,
            reason="test",
        )
        assert result.is_discovery_mode is True

    def test_is_discovery_mode_false(self):
        """is_discovery_mode is False when project is resolved."""
        result = ResolvedProject(
            project="test",
            mode=ResolutionMode.EXPLICIT,
            reason="test",
        )
        assert result.is_discovery_mode is False

    def test_frozen_dataclass(self):
        """ResolvedProject is immutable."""
        result = ResolvedProject(
            project="test",
            mode=ResolutionMode.EXPLICIT,
            reason="test",
        )
        with pytest.raises(AttributeError):
            result.project = "changed"  # type: ignore