"""Tests for accounts app models."""

import pytest
from django.contrib.auth import get_user_model
from django.db import IntegrityError

from .factories import UserFactory, WorkspaceFactory, WorkspaceMembershipFactory

User = get_user_model()


@pytest.mark.django_db
class TestUser:
    """Tests for the User model."""

    def test_create_user(self):
        """Test creating a user with the factory."""
        user = UserFactory()
        assert user.pk is not None
        assert user.is_active is True
        assert user.username.startswith("user")

    def test_user_email_format(self):
        """Test that user email follows expected format."""
        user = UserFactory(username="testuser")
        assert user.email == "testuser@example.com"

    def test_create_superuser(self):
        """Test creating a superuser."""
        user = UserFactory(is_staff=True, is_superuser=True)
        assert user.is_staff is True
        assert user.is_superuser is True


@pytest.mark.django_db
class TestWorkspace:
    """Tests for the Workspace model."""

    def test_create_workspace(self):
        """Test creating a workspace with the factory."""
        workspace = WorkspaceFactory()
        assert workspace.pk is not None
        assert workspace.name.startswith("Workspace")
        assert workspace.slug.startswith("workspace-")

    def test_workspace_str(self):
        """Test workspace string representation."""
        workspace = WorkspaceFactory(slug="my-workspace")
        assert str(workspace) == "my-workspace"

    def test_workspace_slug_unique(self):
        """Test that workspace slugs must be unique."""
        WorkspaceFactory(slug="unique-slug")
        with pytest.raises(IntegrityError):
            WorkspaceFactory(slug="unique-slug")

    def test_workspace_has_timestamps(self):
        """Test that workspace has created_at and updated_at."""
        workspace = WorkspaceFactory()
        assert workspace.created_at is not None
        assert workspace.updated_at is not None


@pytest.mark.django_db
class TestWorkspaceMembership:
    """Tests for the WorkspaceMembership model."""

    def test_create_membership(self):
        """Test creating a workspace membership."""
        membership = WorkspaceMembershipFactory()
        assert membership.pk is not None
        assert membership.role == "member"

    def test_membership_roles(self):
        """Test different membership roles."""
        owner = WorkspaceMembershipFactory(role="owner")
        admin = WorkspaceMembershipFactory(role="admin")
        member = WorkspaceMembershipFactory(role="member")
        viewer = WorkspaceMembershipFactory(role="viewer")

        assert owner.role == "owner"
        assert admin.role == "admin"
        assert member.role == "member"
        assert viewer.role == "viewer"

    def test_membership_str(self):
        """Test membership string representation."""
        membership = WorkspaceMembershipFactory(role="admin")
        expected = f"{membership.user} in {membership.workspace} as admin"
        assert str(membership) == expected

    def test_unique_user_workspace(self):
        """Test that a user can only have one membership per workspace."""
        membership = WorkspaceMembershipFactory()
        with pytest.raises(IntegrityError):
            WorkspaceMembershipFactory(user=membership.user, workspace=membership.workspace)