"""
Comprehensive tests for Favorite Projects functionality.

This module tests:
- UserFavoriteProject model creation and validation
- Relationships between User and Project models
- Favorite/unfavorite routes and API endpoints
- Filtering projects by favorites
- User permissions and access control
"""

import pytest
from datetime import datetime
from decimal import Decimal
from app import create_app, db
from app.models import User, Project, Client, UserFavoriteProject


@pytest.fixture
def app():
    """Create and configure a test application instance."""
    app = create_app(
        {
            "TESTING": True,
            "SQLALCHEMY_DATABASE_URI": "sqlite:///:memory:",
            "WTF_CSRF_ENABLED": False,
            "SECRET_KEY": "test-secret-key-do-not-use-in-production",
            "SERVER_NAME": "localhost:5000",
            "APPLICATION_ROOT": "/",
            "PREFERRED_URL_SCHEME": "http",
        }
    )

    with app.app_context():
        db.create_all()
        yield app
        db.session.remove()
        db.drop_all()


@pytest.fixture
def client_fixture(app):
    """Create a test Flask client."""
    return app.test_client()


@pytest.fixture
def test_user(app):
    """Create a test user."""
    with app.app_context():
        user = User(username="testuser", role="user")
        db.session.add(user)
        db.session.commit()
        return user.id


@pytest.fixture
def test_admin(app):
    """Create a test admin user."""
    with app.app_context():
        admin = User(username="admin", role="admin")
        db.session.add(admin)
        db.session.commit()
        return admin.id


@pytest.fixture
def test_client(app):
    """Create a test client."""
    with app.app_context():
        client = Client(name="Test Client", description="A test client")
        db.session.add(client)
        db.session.commit()
        return client.id


@pytest.fixture
def test_project(app, test_client):
    """Create a test project."""
    with app.app_context():
        project = Project(
            name="Test Project",
            client_id=test_client,
            description="A test project",
            billable=True,
            hourly_rate=Decimal("100.00"),
        )
        db.session.add(project)
        db.session.commit()
        return project.id


@pytest.fixture
def test_project_2(app, test_client):
    """Create a second test project."""
    with app.app_context():
        project = Project(
            name="Test Project 2",
            client_id=test_client,
            description="Another test project",
            billable=True,
            hourly_rate=Decimal("150.00"),
        )
        db.session.add(project)
        db.session.commit()
        return project.id


# Model Tests


class TestUserFavoriteProjectModel:
    """Test UserFavoriteProject model creation, validation, and basic operations."""

    def test_create_favorite(self, app, test_user, test_project):
        """Test creating a favorite project entry."""
        with app.app_context():
            favorite = UserFavoriteProject()
            favorite.user_id = test_user
            favorite.project_id = test_project

            db.session.add(favorite)
            db.session.commit()

            assert favorite.id is not None
            assert favorite.user_id == test_user
            assert favorite.project_id == test_project
            assert favorite.created_at is not None
            assert isinstance(favorite.created_at, datetime)

    def test_favorite_unique_constraint(self, app, test_user, test_project):
        """Test that a user cannot favorite the same project twice."""
        with app.app_context():
            # Create first favorite
            favorite1 = UserFavoriteProject()
            favorite1.user_id = test_user
            favorite1.project_id = test_project
            db.session.add(favorite1)
            db.session.commit()

            # Try to create duplicate
            favorite2 = UserFavoriteProject()
            favorite2.user_id = test_user
            favorite2.project_id = test_project
            db.session.add(favorite2)

            # Should raise IntegrityError
            with pytest.raises(Exception):  # SQLAlchemy will raise IntegrityError
                db.session.commit()

    def test_favorite_to_dict(self, app, test_user, test_project):
        """Test favorite project to_dict method."""
        with app.app_context():
            favorite = UserFavoriteProject()
            favorite.user_id = test_user
            favorite.project_id = test_project
            db.session.add(favorite)
            db.session.commit()

            data = favorite.to_dict()
            assert "id" in data
            assert "user_id" in data
            assert "project_id" in data
            assert "created_at" in data
            assert data["user_id"] == test_user
            assert data["project_id"] == test_project


class TestUserFavoriteProjectMethods:
    """Test User model methods for managing favorite projects."""

    def test_add_favorite_project(self, app, test_user, test_project):
        """Test adding a project to user's favorites."""
        with app.app_context():
            user = db.session.get(User, test_user)
            project = db.session.get(Project, test_project)

            # Add to favorites
            user.add_favorite_project(project)

            # Verify it was added
            assert user.is_project_favorite(project)
            assert project in user.favorite_projects.all()

    def test_add_favorite_project_idempotent(self, app, test_user, test_project):
        """Test that adding a favorite twice doesn't cause errors."""
        with app.app_context():
            user = db.session.get(User, test_user)
            project = db.session.get(Project, test_project)

            # Add twice
            user.add_favorite_project(project)
            user.add_favorite_project(project)

            # Should still only have one favorite entry
            favorites = UserFavoriteProject.query.filter_by(user_id=test_user, project_id=test_project).all()
            assert len(favorites) == 1

    def test_remove_favorite_project(self, app, test_user, test_project):
        """Test removing a project from user's favorites."""
        with app.app_context():
            user = db.session.get(User, test_user)
            project = db.session.get(Project, test_project)

            # Add then remove
            user.add_favorite_project(project)
            assert user.is_project_favorite(project)

            user.remove_favorite_project(project)
            assert not user.is_project_favorite(project)

    def test_is_project_favorite_with_id(self, app, test_user, test_project):
        """Test checking if project is favorite using project ID."""
        with app.app_context():
            user = db.session.get(User, test_user)
            project = db.session.get(Project, test_project)

            # Not a favorite yet
            assert not user.is_project_favorite(test_project)

            # Add to favorites
            user.add_favorite_project(project)

            # Check with ID
            assert user.is_project_favorite(test_project)

    def test_get_favorite_projects(self, app, test_user, test_project, test_project_2):
        """Test getting user's favorite projects."""
        with app.app_context():
            user = db.session.get(User, test_user)
            project1 = db.session.get(Project, test_project)
            project2 = db.session.get(Project, test_project_2)

            # Add both to favorites
            user.add_favorite_project(project1)
            user.add_favorite_project(project2)

            # Get favorites
            favorites = user.get_favorite_projects()
            assert len(favorites) == 2
            assert project1 in favorites
            assert project2 in favorites

    def test_get_favorite_projects_filtered_by_status(self, app, test_user, test_project, test_project_2):
        """Test getting favorite projects filtered by status."""
        with app.app_context():
            user = db.session.get(User, test_user)
            project1 = db.session.get(Project, test_project)
            project2 = db.session.get(Project, test_project_2)

            # Set different statuses
            project1.status = "active"
            project2.status = "archived"
            db.session.commit()

            # Add both to favorites
            user.add_favorite_project(project1)
            user.add_favorite_project(project2)

            # Get only active favorites
            active_favorites = user.get_favorite_projects(status="active")
            assert len(active_favorites) == 1
            assert project1 in active_favorites
            assert project2 not in active_favorites


class TestProjectFavoriteMethods:
    """Test Project model methods for favorite functionality."""

    def test_is_favorited_by_user(self, app, test_user, test_project):
        """Test checking if project is favorited by a specific user."""
        with app.app_context():
            user = db.session.get(User, test_user)
            project = db.session.get(Project, test_project)

            # Not favorited yet
            assert not project.is_favorited_by(user)

            # Add to favorites
            user.add_favorite_project(project)

            # Now should be favorited
            assert project.is_favorited_by(user)

    def test_is_favorited_by_user_id(self, app, test_user, test_project):
        """Test checking if project is favorited using user ID."""
        with app.app_context():
            user = db.session.get(User, test_user)
            project = db.session.get(Project, test_project)

            # Add to favorites
            user.add_favorite_project(project)

            # Check with user ID
            assert project.is_favorited_by(test_user)

    def test_project_to_dict_with_favorite_status(self, app, test_user, test_project):
        """Test project to_dict includes favorite status when user provided."""
        with app.app_context():
            user = db.session.get(User, test_user)
            project = db.session.get(Project, test_project)

            # Without user, no is_favorite field
            data = project.to_dict()
            assert "is_favorite" not in data

            # With user, includes is_favorite
            data_with_user = project.to_dict(user=user)
            assert "is_favorite" in data_with_user
            assert data_with_user["is_favorite"] is False

            # Add to favorites
            user.add_favorite_project(project)

            # Now should be True
            data_favorited = project.to_dict(user=user)
            assert data_favorited["is_favorite"] is True


# Route Tests


class TestFavoriteProjectRoutes:
    """Test favorite project routes and endpoints."""

    def test_favorite_project_route(self, app, client_fixture, test_user, test_project):
        """Test favoriting a project via POST route."""
        with app.app_context():
            # Login as test user
            with client_fixture.session_transaction() as sess:
                sess["_user_id"] = str(test_user)

            # Favorite the project
            response = client_fixture.post(
                f"/projects/{test_project}/favorite", headers={"X-Requested-With": "XMLHttpRequest"}
            )

            assert response.status_code == 200
            data = response.get_json()
            assert data["success"] is True

            # Verify in database
            user = db.session.get(User, test_user)
            assert user.is_project_favorite(test_project)

    def test_unfavorite_project_route(self, app, client_fixture, test_user, test_project):
        """Test unfavoriting a project via POST route."""
        with app.app_context():
            # Setup: Add to favorites first
            user = db.session.get(User, test_user)
            project = db.session.get(Project, test_project)
            user.add_favorite_project(project)

            # Login
            with client_fixture.session_transaction() as sess:
                sess["_user_id"] = str(test_user)

            # Unfavorite the project
            response = client_fixture.post(
                f"/projects/{test_project}/unfavorite", headers={"X-Requested-With": "XMLHttpRequest"}
            )

            assert response.status_code == 200
            data = response.get_json()
            assert data["success"] is True

            # Verify in database
            user = db.session.get(User, test_user)
            assert not user.is_project_favorite(test_project)

    def test_favorite_nonexistent_project(self, app, client_fixture, test_user):
        """Test favoriting a non-existent project returns 404."""
        with app.app_context():
            with client_fixture.session_transaction() as sess:
                sess["_user_id"] = str(test_user)

            response = client_fixture.post("/projects/99999/favorite")
            assert response.status_code == 404

    def test_favorite_project_requires_login(self, app, client_fixture, test_project):
        """Test that favoriting requires authentication."""
        with app.app_context():
            response = client_fixture.post(f"/projects/{test_project}/favorite")
            # Should redirect to login
            assert response.status_code in [302, 401]


class TestFavoriteProjectFiltering:
    """Test filtering projects by favorites."""

    def test_list_projects_with_favorites_filter(self, app, client_fixture, test_user, test_project, test_project_2):
        """Test listing only favorite projects."""
        with app.app_context():
            # Setup: Favorite only one project
            user = db.session.get(User, test_user)
            project1 = db.session.get(Project, test_project)
            user.add_favorite_project(project1)

            # Login
            with client_fixture.session_transaction() as sess:
                sess["_user_id"] = str(test_user)

            # Request favorites only
            response = client_fixture.get("/projects?favorites=true")

            assert response.status_code == 200
            # Check that the response contains the favorite project
            assert b"Test Project" in response.data

    def test_list_all_projects_without_filter(self, app, client_fixture, test_user, test_project, test_project_2):
        """Test listing all projects without favorites filter."""
        with app.app_context():
            # Setup: Favorite only one project
            user = db.session.get(User, test_user)
            project1 = db.session.get(Project, test_project)
            user.add_favorite_project(project1)

            # Login
            with client_fixture.session_transaction() as sess:
                sess["_user_id"] = str(test_user)

            # Request all projects
            response = client_fixture.get("/projects")

            assert response.status_code == 200
            # Both projects should be in response
            assert b"Test Project" in response.data


# Relationship Tests


class TestFavoriteProjectRelationships:
    """Test database relationships and cascade behavior."""

    def test_delete_user_cascades_favorites(self, app, test_user, test_project):
        """Test that deleting a user removes their favorite entries."""
        with app.app_context():
            user = db.session.get(User, test_user)
            project = db.session.get(Project, test_project)

            # Add to favorites
            user.add_favorite_project(project)

            # Verify favorite exists
            favorite_count = UserFavoriteProject.query.filter_by(user_id=test_user).count()
            assert favorite_count == 1

            # Delete user
            db.session.delete(user)
            db.session.commit()

            # Favorite should be deleted
            favorite_count = UserFavoriteProject.query.filter_by(user_id=test_user).count()
            assert favorite_count == 0

    def test_delete_project_cascades_favorites(self, app, test_user, test_project):
        """Test that deleting a project removes related favorite entries."""
        with app.app_context():
            user = db.session.get(User, test_user)
            project = db.session.get(Project, test_project)

            # Add to favorites
            user.add_favorite_project(project)

            # Verify favorite exists
            favorite_count = UserFavoriteProject.query.filter_by(project_id=test_project).count()
            assert favorite_count == 1

            # Delete project
            db.session.delete(project)
            db.session.commit()

            # Favorite should be deleted
            favorite_count = UserFavoriteProject.query.filter_by(project_id=test_project).count()
            assert favorite_count == 0

    def test_multiple_users_favorite_same_project(self, app, test_user, test_admin, test_project):
        """Test that multiple users can favorite the same project."""
        with app.app_context():
            user = db.session.get(User, test_user)
            admin = db.session.get(User, test_admin)
            project = db.session.get(Project, test_project)

            # Both favorite the same project
            user.add_favorite_project(project)
            admin.add_favorite_project(project)

            # Verify both have it as favorite
            assert user.is_project_favorite(project)
            assert admin.is_project_favorite(project)

            # Verify database has 2 entries
            favorite_count = UserFavoriteProject.query.filter_by(project_id=test_project).count()
            assert favorite_count == 2


# Smoke Tests


class TestFavoriteProjectsSmoke:
    """Smoke tests to verify basic favorite projects functionality."""

    def test_complete_favorite_workflow(self, app, test_user, test_project):
        """Test complete workflow: add favorite, check status, remove favorite."""
        with app.app_context():
            user = db.session.get(User, test_user)
            project = db.session.get(Project, test_project)

            # Initially not favorited
            assert not user.is_project_favorite(project)

            # Add to favorites
            user.add_favorite_project(project)
            assert user.is_project_favorite(project)

            # Get favorites list
            favorites = user.get_favorite_projects()
            assert len(favorites) == 1
            assert project in favorites

            # Remove from favorites
            user.remove_favorite_project(project)
            assert not user.is_project_favorite(project)

            # Favorites list should be empty
            favorites = user.get_favorite_projects()
            assert len(favorites) == 0

    def test_favorite_with_archived_projects(self, app, test_user, test_project):
        """Test that favoriting works with archived projects."""
        with app.app_context():
            user = db.session.get(User, test_user)
            project = db.session.get(Project, test_project)

            # Favorite an active project
            user.add_favorite_project(project)

            # Archive the project
            project.status = "archived"
            db.session.commit()

            # Should still be favorited
            assert user.is_project_favorite(project)

            # But won't appear in active favorites
            active_favorites = user.get_favorite_projects(status="active")
            assert len(active_favorites) == 0

            # Will appear in archived favorites
            archived_favorites = user.get_favorite_projects(status="archived")
            assert len(archived_favorites) == 1