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

from .models import Torrent, SharedUser, File
from user.models import User
from .views import TorrentViewSet, FileViewSet
from .utils import Transmission, torrent_proceed, torrent_share


class TorrentModelTestCase(TestCase):
    def setUp(self):
        self.user = User.objects.create_user(
            username='testuser',
            email='test@example.com',
            password='testpassword'
        )
        self.torrent = Torrent.objects.create(
            id='abc123',
            name='Test Torrent',
            user=self.user,
            size=1000,
            transmission_data={}
        )
        self.shared_user = User.objects.create_user(
            username='shareduser',
            email='shared@example.com',
            password='sharedpassword'
        )
        self.file = File.objects.create(
            torrent=self.torrent,
            rel_name='test_file.txt',
            size=100
        )

    def test_len_files(self):
        """Test the len_files property returns the correct count of files"""
        self.assertEqual(self.torrent.len_files, 1)

        # Add another file and test again
        File.objects.create(
            torrent=self.torrent,
            rel_name='another_file.txt',
            size=200
        )

        # Clear cached_property
        if hasattr(self.torrent, '_len_files'):
            delattr(self.torrent, '_len_files')

        self.assertEqual(self.torrent.len_files, 2)

    def test_related_users(self):
        """Test the related_users property returns the correct list of users"""
        # Initially only the owner
        self.assertEqual(self.torrent.related_users, [self.user.id])

        # Add a shared user
        self.torrent.shared_users.add(self.shared_user)

        # Clear cached_property
        if hasattr(self.torrent, '_related_users'):
            delattr(self.torrent, '_related_users')

        # Should include both users now
        self.assertIn(self.user.id, self.torrent.related_users)
        self.assertIn(self.shared_user.id, self.torrent.related_users)


class FileModelTestCase(TestCase):
    def setUp(self):
        self.user = User.objects.create_user(
            username='testuser',
            email='test@example.com',
            password='testpassword'
        )
        self.torrent = Torrent.objects.create(
            id='abc123',
            name='Test Torrent',
            user=self.user,
            size=1000,
            transmission_data={}
        )
        self.file = File.objects.create(
            torrent=self.torrent,
            rel_name='test/path/file.mp4',
            size=100
        )

    def test_pathname(self):
        """Test the pathname property returns the correct path"""
        self.assertEqual(str(self.file.pathname), 'test/path/file.mp4')

    def test_filename(self):
        """Test the filename property returns the correct filename"""
        self.assertEqual(self.file.filename, 'file.mp4')

    def test_abs_pathname(self):
        """Test the abs_pathname property returns the correct absolute path"""
        expected_path = settings.DOWNLOAD_BASE_DIR / self.file.pathname
        self.assertEqual(self.file.abs_pathname, expected_path)

    def test_is_video(self):
        """Test the is_video property correctly identifies video files"""
        self.assertTrue(self.file.is_video)  # mp4 should be identified as video

        # Test non-video file
        non_video_file = File.objects.create(
            torrent=self.torrent,
            rel_name='test/path/document.pdf',
            size=50
        )
        self.assertFalse(non_video_file.is_video)


class SharedUserModelTestCase(TestCase):
    def setUp(self):
        self.owner = User.objects.create_user(
            username='owner',
            email='owner@example.com',
            password='ownerpassword'
        )
        self.shared_user = User.objects.create_user(
            username='shareduser',
            email='shared@example.com',
            password='sharedpassword'
        )
        self.torrent = Torrent.objects.create(
            id='abc123',
            name='Test Torrent',
            user=self.owner,
            size=1000,
            transmission_data={}
        )

    def test_shared_user_creation(self):
        """Test creating a shared user relationship"""
        shared = SharedUser.objects.create(
            user=self.shared_user,
            torrent=self.torrent
        )
        self.assertEqual(shared.user, self.shared_user)
        self.assertEqual(shared.torrent, self.torrent)

        # Verify the relationship is reflected in the torrent's shared_users
        self.assertIn(self.shared_user, self.torrent.shared_users.all())


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

        self.torrent = Torrent.objects.create(
            id='abc123',
            name='Test Torrent',
            user=self.user,
            size=1000,
            transmission_data={}
        )

        self.file = File.objects.create(
            torrent=self.torrent,
            rel_name='test_file.txt',
            size=100
        )

    def test_list_torrents(self):
        """Test listing torrents"""
        url = reverse('torrent-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]['id'], self.torrent.id)

    def test_retrieve_torrent(self):
        """Test retrieving a specific torrent"""
        url = reverse('torrent-detail', args=[self.torrent.id])
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(response.data['id'], self.torrent.id)
        self.assertEqual(response.data['name'], 'Test Torrent')

    @patch('torrent.views.torrent_share')
    def test_share_torrent(self, mock_torrent_share):
        """Test sharing a torrent with another user"""
        mock_torrent_share.return_value = True

        shared_user = User.objects.create_user(
            username='shareduser',
            email='shared@example.com',
            password='sharedpassword'
        )

        url = reverse('torrent-share', args=[self.torrent.id])
        response = self.client.post(url, {'user_id': shared_user.id})

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertTrue(response.data['success'])
        mock_torrent_share.assert_called_once()


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

        self.torrent = Torrent.objects.create(
            id='abc123',
            name='Test Torrent',
            user=self.user,
            size=1000,
            transmission_data={}
        )

        self.file = File.objects.create(
            torrent=self.torrent,
            rel_name='test_file.txt',
            size=100
        )

    def test_list_files(self):
        """Test listing files"""
        url = reverse('file-list')
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)

    def test_retrieve_file(self):
        """Test retrieving a specific file"""
        url = reverse('file-detail', args=[self.file.id])
        response = self.client.get(url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(response.data['id'], str(self.file.id))
        self.assertEqual(response.data['rel_name'], 'test_file.txt')


class TransmissionUtilsTestCase(TestCase):
    @patch('torrent.utils.Client')
    def test_transmission_init(self, mock_client):
        """Test Transmission class initialization"""
        transmission = Transmission()
        mock_client.assert_called_once_with(**settings.TRANSMISSION)

    @patch('torrent.utils.Client')
    def test_add_torrent(self, mock_client):
        """Test adding a torrent"""
        mock_instance = mock_client.return_value
        mock_instance.add_torrent.return_value = MagicMock()

        transmission = Transmission()
        file_obj = MagicMock()
        result = transmission.add_torrent(file_obj)

        mock_instance.add_torrent.assert_called_once_with(file_obj)
        self.assertEqual(result, mock_instance.add_torrent.return_value)

    @patch('torrent.utils.Client')
    def test_get_data(self, mock_client):
        """Test getting torrent data"""
        mock_instance = mock_client.return_value
        mock_torrent = MagicMock()
        mock_torrent.progress = 50
        mock_torrent.fields = {'name': 'Test', 'size': 1000}
        mock_instance.get_torrent.return_value = mock_torrent

        transmission = Transmission()
        result = transmission.get_data('hash123')

        mock_instance.get_torrent.assert_called_once_with('hash123', transmission.trpc_args)
        self.assertEqual(result['progress'], 50)
        self.assertEqual(result['name'], 'Test')
        self.assertEqual(result['size'], 1000)


class TorrentProceedTestCase(TestCase):
    def setUp(self):
        self.user = User.objects.create_user(
            username='testuser',
            email='test@example.com',
            password='testpassword',
            max_size=10000
        )

    @patch('torrent.utils.transmission_handler')
    def test_torrent_proceed_size_exceed(self, mock_transmission):
        """Test torrent_proceed when user size is exceeded"""
        # Set user's used size to exceed max_size
        self.user.max_size = 100
        Torrent.objects.create(
            id='abc123',
            name='Test Torrent',
            user=self.user,
            size=200,  # Exceeds max_size
            transmission_data={}
        )

        file_obj = MagicMock()
        result = torrent_proceed(self.user, file_obj)

        self.assertEqual(result['status'], 'error')
        self.assertEqual(result['message'], 'Size exceed')
        mock_transmission.add_torrent.assert_not_called()

    @patch('torrent.utils.transmission_handler')
    def test_torrent_proceed_transmission_error(self, mock_transmission):
        """Test torrent_proceed when transmission raises an error"""
        from transmission_rpc.error import TransmissionError

        mock_transmission.add_torrent.side_effect = TransmissionError('Test error')

        file_obj = MagicMock()
        result = torrent_proceed(self.user, file_obj)

        self.assertEqual(result['status'], 'error')
        self.assertEqual(result['message'], 'Transmission Error')