from django.test import TestCase
from django.urls import reverse
from rest_framework.test import APITestCase, APIClient
from rest_framework import status
from unittest.mock import patch, MagicMock

from .models import User, FriendRequest, Invitation, UsernameUserManager
from torrent.models import Torrent
from .views import UserViewSet, FriendRequestViewSet


class UserModelTestCase(TestCase):
    def setUp(self):
        self.user = User.objects.create_user(
            username='testuser',
            email='test@example.com',
            password='testpassword',
            max_size=1000000
        )
        self.friend = User.objects.create_user(
            username='frienduser',
            email='friend@example.com',
            password='friendpassword'
        )

    def test_size_used_property(self):
        """Test the size_used property returns the correct total size of user's torrents"""
        # Initially no torrents, so size should be 0
        self.assertEqual(self.user.size_used, 0)

        # Create a torrent for the user
        Torrent.objects.create(
            id='abc123',
            name='Test Torrent',
            user=self.user,
            size=5000,
            transmission_data={}
        )

        # Create another torrent
        Torrent.objects.create(
            id='def456',
            name='Another Torrent',
            user=self.user,
            size=3000,
            transmission_data={}
        )

        # Clear cached_property if it exists
        if hasattr(self.user, 'total_size'):
            delattr(self.user, 'total_size')

        # Size used should be the sum of torrent sizes
        self.assertEqual(self.user.size_used, 8000)

    def test_min_infos_property(self):
        """Test the min_infos property returns the correct user info"""
        expected_info = {
            'username': 'testuser',
            'id': self.user.id
        }
        self.assertEqual(self.user.min_infos, expected_info)


class UsernameUserManagerTestCase(TestCase):
    def test_create_user(self):
        """Test creating a regular user"""
        user = User.objects.create_user(
            username='newuser',
            email='new@example.com',
            password='newpassword'
        )
        self.assertFalse(user.is_staff)
        self.assertFalse(user.is_superuser)
        self.assertEqual(user.username, 'newuser')
        self.assertEqual(user.email, 'new@example.com')
        self.assertTrue(user.check_password('newpassword'))

    def test_create_superuser(self):
        """Test creating a superuser"""
        admin = User.objects.create_superuser(
            username='admin',
            email='admin@example.com',
            password='adminpassword'
        )
        self.assertTrue(admin.is_staff)
        self.assertTrue(admin.is_superuser)
        self.assertEqual(admin.username, 'admin')
        self.assertEqual(admin.email, 'admin@example.com')

    def test_create_user_without_username(self):
        """Test creating a user without username raises error"""
        with self.assertRaises(ValueError):
            User.objects.create_user(
                username='',
                email='test@example.com',
                password='testpassword'
            )

    def test_create_user_without_email(self):
        """Test creating a user without email raises error"""
        with self.assertRaises(ValueError):
            User.objects.create_user(
                username='testuser',
                email='',
                password='testpassword'
            )


class FriendRequestModelTestCase(TestCase):
    def setUp(self):
        self.sender = User.objects.create_user(
            username='sender',
            email='sender@example.com',
            password='senderpassword'
        )
        self.receiver = User.objects.create_user(
            username='receiver',
            email='receiver@example.com',
            password='receiverpassword'
        )

    def test_friend_request_creation(self):
        """Test creating a friend request"""
        friend_request = FriendRequest.objects.create(
            sender=self.sender,
            receiver=self.receiver
        )
        self.assertEqual(friend_request.sender, self.sender)
        self.assertEqual(friend_request.receiver, self.receiver)

    def test_unique_together_constraint(self):
        """Test that the unique_together constraint works"""
        FriendRequest.objects.create(
            sender=self.sender,
            receiver=self.receiver
        )

        # Creating another request with the same sender and receiver should raise an error
        with self.assertRaises(Exception):
            FriendRequest.objects.create(
                sender=self.sender,
                receiver=self.receiver
            )


class InvitationModelTestCase(TestCase):
    def setUp(self):
        self.creator = User.objects.create_user(
            username='creator',
            email='creator@example.com',
            password='creatorpassword'
        )

    def test_invitation_creation(self):
        """Test creating an invitation"""
        invitation = Invitation.objects.create(
            created_by=self.creator
        )
        self.assertEqual(invitation.created_by, self.creator)
        self.assertIsNotNone(invitation.token)
        self.assertIsNone(invitation.user)

    def test_invitation_assignment(self):
        """Test assigning an invitation to a user"""
        invitation = Invitation.objects.create(
            created_by=self.creator
        )

        new_user = User.objects.create_user(
            username='newuser',
            email='new@example.com',
            password='newpassword'
        )

        invitation.user = new_user
        invitation.save()

        # Refresh from database
        invitation.refresh_from_db()
        self.assertEqual(invitation.user, new_user)


class UserViewSetTestCase(APITestCase):
    def setUp(self):
        self.user = User.objects.create_user(
            username='testuser',
            email='test@example.com',
            password='testpassword'
        )
        self.friend = User.objects.create_user(
            username='frienduser',
            email='friend@example.com',
            password='friendpassword'
        )
        self.client = APIClient()
        self.client.force_authenticate(user=self.user)

    def test_list_users(self):
        """Test listing users"""
        url = reverse('user-list')
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(len(response.data), 2)  # Should include both users

    def test_retrieve_user(self):
        """Test retrieving a specific user"""
        url = reverse('user-detail', args=[self.friend.id])
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(response.data['username'], 'frienduser')

    def test_add_friend_request(self):
        """Test adding a friend request"""
        url = reverse('user-add-friend-request', args=[self.friend.username])
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertTrue(response.data['success'])
        self.assertEqual(response.data['message'], 'Request sent')

        # Verify the friend request was created
        self.assertTrue(FriendRequest.objects.filter(
            sender=self.user,
            receiver=self.friend
        ).exists())

    def test_add_friend_request_nonexistent_user(self):
        """Test adding a friend request to a nonexistent user"""
        url = reverse('user-add-friend-request', args=['nonexistentuser'])
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertFalse(response.data['success'])
        self.assertEqual(response.data['message'], "User 'nonexistentuser' doesn't exist")

    def test_remove_friend(self):
        """Test removing a friend"""
        # First add as friend
        self.user.friends.add(self.friend)

        url = reverse('user-remove-friend', args=[self.friend.id])
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertTrue(response.data['success'])

        # Verify the friend was removed
        self.assertFalse(self.user.friends.filter(id=self.friend.id).exists())

    @patch('user.views.shutil.disk_usage')
    def test_user_stats(self, mock_disk_usage):
        """Test getting user stats"""
        # Mock disk_usage return value
        mock_disk_usage.return_value = MagicMock(
            total=1000000,
            used=500000,
            free=500000
        )

        # Create torrents for the user
        Torrent.objects.create(
            id='abc123',
            name='Test Torrent',
            user=self.user,
            size=5000,
            transmission_data={}
        )

        url = reverse('user-user-stats')
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        # Check that the response contains the expected fields
        self.assertIn('torrents_size', response.data)
        self.assertIn('torrents_len', response.data)
        self.assertIn('user_max_size', response.data)
        self.assertIn('disk_total', response.data)
        self.assertIn('disk_used', response.data)
        self.assertIn('disk_free', response.data)


class FriendRequestViewSetTestCase(APITestCase):
    def setUp(self):
        self.user = User.objects.create_user(
            username='testuser',
            email='test@example.com',
            password='testpassword'
        )
        self.sender = User.objects.create_user(
            username='sender',
            email='sender@example.com',
            password='senderpassword'
        )
        self.client = APIClient()
        self.client.force_authenticate(user=self.user)

        # Create a friend request
        self.friend_request = FriendRequest.objects.create(
            sender=self.sender,
            receiver=self.user
        )

    def test_list_friend_requests(self):
        """Test listing friend requests"""
        url = reverse('friendrequest-list')
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(len(response.data), 1)
        self.assertEqual(response.data[0]['sender']['username'], 'sender')

    def test_delete_friend_request(self):
        """Test deleting a friend request"""
        url = reverse('friendrequest-detail', args=[self.friend_request.id])
        response = self.client.delete(url)
        self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)

        # Verify the friend request was deleted
        self.assertFalse(FriendRequest.objects.filter(id=self.friend_request.id).exists())