"""Unit tests for Pydantic schemas."""

import pytest
from datetime import datetime
from pydantic import ValidationError

from app.schemas import (
    UserBase, UserCreate, User,
    ProjectBase, ProjectCreate, ProjectJoin, Project,
    TaskBase, TaskCreate, Task,
    TaskCompleteRequest, TaskCompleteResponse,
    SearchRequest, SearchFilters, SearchResponse,
    SmartQueryRequest, SmartQueryResponse
)


class TestUserSchemas:
    """Test User-related schemas."""

    def test_user_base_requires_names(self):
        """Test UserBase requires firstName and lastName."""
        user = UserBase(firstName="John", lastName="Doe")
        assert user.firstName == "John"
        assert user.lastName == "Doe"

    def test_user_base_no_email_field(self):
        """Test UserBase does not have email field."""
        user = UserBase(firstName="Test", lastName="User")
        assert not hasattr(user, "email")

    def test_user_base_optional_avatar(self):
        """Test avatar_url is optional."""
        user = UserBase(firstName="Test", lastName="User")
        assert user.avatar_url is None
        
        user_with_avatar = UserBase(
            firstName="Test",
            lastName="User",
            avatar_url="https://example.com/avatar.png"
        )
        assert user_with_avatar.avatar_url == "https://example.com/avatar.png"

    def test_user_create_inherits_user_base(self):
        """Test UserCreate has same fields as UserBase."""
        user = UserCreate(firstName="New", lastName="User")
        assert user.firstName == "New"
        assert user.lastName == "User"

    def test_user_validation_missing_first_name(self):
        """Test validation fails without firstName."""
        with pytest.raises(ValidationError):
            UserBase(lastName="Doe")

    def test_user_validation_missing_last_name(self):
        """Test validation fails without lastName."""
        with pytest.raises(ValidationError):
            UserBase(firstName="John")

    def test_user_schema_has_id_and_created_at(self):
        """Test User schema includes id and created_at."""
        user = User(
            id="tes1234",
            firstName="Test",
            lastName="User",
            created_at=datetime.now()
        )
        assert user.id == "tes1234"
        assert user.created_at is not None


class TestProjectSchemas:
    """Test Project-related schemas."""

    def test_project_base(self):
        """Test ProjectBase schema."""
        project = ProjectBase(name="myproject", description="A test project")
        assert project.name == "myproject"
        assert project.description == "A test project"

    def test_project_create_requires_user_id(self):
        """Test ProjectCreate requires userId."""
        project = ProjectCreate(
            name="testproj",
            description="Test",
            userId="usr1234"
        )
        assert project.userId == "usr1234"

    def test_project_join_schema(self):
        """Test ProjectJoin schema."""
        join = ProjectJoin(userId="usr1234")
        assert join.userId == "usr1234"

    def test_project_schema(self):
        """Test full Project schema."""
        project = Project(
            id="myproject",
            name="myproject",
            description="Test",
            created_by="usr1234",
            created_at=datetime.now()
        )
        assert project.id == project.name  # ID is the name


class TestTaskSchemas:
    """Test Task-related schemas."""

    def test_task_base(self):
        """Test TaskBase schema."""
        task = TaskBase(title="Test Task")
        assert task.title == "Test Task"
        assert task.description is None

    def test_task_create_optional_assigned_to(self):
        """Test TaskCreate has optional assignedTo."""
        task = TaskCreate(title="Unassigned Task")
        assert task.assignedTo is None
        
        assigned_task = TaskCreate(title="Assigned", assignedTo="usr1234")
        assert assigned_task.assignedTo == "usr1234"

    def test_task_complete_request(self):
        """Test TaskCompleteRequest schema."""
        request = TaskCompleteRequest(
            userId="usr1234",
            whatIDid="Fixed the bug",
            codeSnippet="def fix(): pass"
        )
        assert request.userId == "usr1234"
        assert request.whatIDid == "Fixed the bug"
        assert request.codeSnippet == "def fix(): pass"

    def test_task_complete_request_optional_code(self):
        """Test codeSnippet is optional."""
        request = TaskCompleteRequest(
            userId="usr1234",
            whatIDid="Fixed the bug"
        )
        assert request.codeSnippet is None


class TestSearchSchemas:
    """Test Search-related schemas."""

    def test_search_filters_all_optional(self):
        """Test SearchFilters has all optional fields."""
        filters = SearchFilters()
        assert filters.userId is None
        assert filters.dateFrom is None
        assert filters.dateTo is None
        assert filters.tags is None

    def test_search_request(self):
        """Test SearchRequest schema."""
        request = SearchRequest(query="authentication")
        assert request.query == "authentication"
        assert request.filters is None

    def test_search_request_with_filters(self):
        """Test SearchRequest with filters."""
        filters = SearchFilters(userId="usr1234", tags=["auth", "security"])
        request = SearchRequest(query="login", filters=filters)
        assert request.filters.userId == "usr1234"
        assert request.filters.tags == ["auth", "security"]


class TestSmartQuerySchemas:
    """Test SmartQuery-related schemas."""

    def test_smart_query_request(self):
        """Test SmartQueryRequest schema."""
        request = SmartQueryRequest(
            query="What did I do yesterday?",
            currentUserId="usr1234"
        )
        assert request.query == "What did I do yesterday?"
        assert request.currentUserId == "usr1234"
        assert request.currentDatetime is None

    def test_smart_query_request_with_datetime(self):
        """Test SmartQueryRequest with datetime."""
        request = SmartQueryRequest(
            query="What tasks are done?",
            currentUserId="usr1234",
            currentDatetime="2025-11-30T12:00:00Z"
        )
        assert request.currentDatetime == "2025-11-30T12:00:00Z"

    def test_smart_query_response(self):
        """Test SmartQueryResponse schema."""
        response = SmartQueryResponse(
            answer="You completed the auth task yesterday.",
            tools_used=["get_user_activity"],
            sources=[]
        )
        assert response.answer == "You completed the auth task yesterday."
        assert "get_user_activity" in response.tools_used