"""
Unit tests for dev-only referral URL generator endpoint.
"""
from django.test import TestCase, override_settings
from django.urls import reverse
from rest_framework import status
from rest_framework.test import APIClient
from apps.users.models import User


class GenerateReferralTestUrlViewTests(TestCase):
    """Test the dev-only generate_referral_test_url endpoint."""

    def setUp(self):
        self.client = APIClient()
        self.url = reverse('generate-referral-test-url')
        
        # Create a referrer user
        self.referrer = User.objects.create(
            telegram_user_id=12345,
            username='referrer',
            first_name='Referrer',
            referral_code='test123abc',
        )

    @override_settings(DEBUG=False, ENABLE_DEV_TELEGRAM_AUTH=False)
    def test_endpoint_returns_404_in_production(self):
        """Endpoint should return 404 when DEBUG=False."""
        response = self.client.post(
            self.url,
            {
                'first_name': 'TestUser',
                'username': 'testuser',
                'referral_code': self.referrer.referral_code,
            },
            format='json',
        )
        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)

    @override_settings(DEBUG=True, ENABLE_DEV_TELEGRAM_AUTH=False)
    def test_endpoint_returns_404_when_dev_auth_disabled(self):
        """Endpoint should return 404 when ENABLE_DEV_TELEGRAM_AUTH=False."""
        response = self.client.post(
            self.url,
            {
                'first_name': 'TestUser',
                'username': 'testuser',
                'referral_code': self.referrer.referral_code,
            },
            format='json',
        )
        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)

    @override_settings(DEBUG=True, ENABLE_DEV_TELEGRAM_AUTH=True, TELEGRAM_BOT_TOKEN="test-bot-token")
    def test_endpoint_works_in_dev_mode(self):
        """Endpoint should work when both DEBUG and ENABLE_DEV_TELEGRAM_AUTH are True."""
        response = self.client.post(
            self.url,
            {
                'first_name': 'TestUser',
                'username': 'testuser',
                'referral_code': self.referrer.referral_code,
            },
            format='json',
        )
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertIn('url', response.data)
        self.assertIn('user_id', response.data)
        self.assertIn('init_data', response.data)

    @override_settings(DEBUG=True, ENABLE_DEV_TELEGRAM_AUTH=True, TELEGRAM_BOT_TOKEN="test-bot-token")
    def test_missing_first_name_returns_400(self):
        """Endpoint should return 400 when first_name is missing."""
        response = self.client.post(
            self.url,
            {
                'username': 'testuser',
                'referral_code': self.referrer.referral_code,
            },
            format='json',
        )
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
        self.assertIn('error', response.data)

    @override_settings(DEBUG=True, ENABLE_DEV_TELEGRAM_AUTH=True, TELEGRAM_BOT_TOKEN="test-bot-token")
    def test_missing_referral_code_returns_400(self):
        """Endpoint should return 400 when referral_code is missing."""
        response = self.client.post(
            self.url,
            {
                'first_name': 'TestUser',
                'username': 'testuser',
            },
            format='json',
        )
        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
        self.assertIn('error', response.data)

    @override_settings(DEBUG=True, ENABLE_DEV_TELEGRAM_AUTH=True, TELEGRAM_BOT_TOKEN="test-bot-token")
    def test_username_is_optional(self):
        """Endpoint should work without username."""
        response = self.client.post(
            self.url,
            {
                'first_name': 'TestUser',
                'referral_code': self.referrer.referral_code,
            },
            format='json',
        )
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(response.data['first_name'], 'TestUser')
        self.assertEqual(response.data['username'], '')

    @override_settings(DEBUG=True, ENABLE_DEV_TELEGRAM_AUTH=True, TELEGRAM_BOT_TOKEN="test-bot-token")
    def test_user_id_is_auto_generated(self):
        """Endpoint should auto-generate unique user IDs."""
        response1 = self.client.post(
            self.url,
            {
                'first_name': 'User1',
                'referral_code': self.referrer.referral_code,
            },
            format='json',
        )
        response2 = self.client.post(
            self.url,
            {
                'first_name': 'User2',
                'referral_code': self.referrer.referral_code,
            },
            format='json',
        )
        
        self.assertEqual(response1.status_code, status.HTTP_200_OK)
        self.assertEqual(response2.status_code, status.HTTP_200_OK)
        
        # User IDs should be different
        self.assertNotEqual(response1.data['user_id'], response2.data['user_id'])
        
        # User IDs should be positive integers
        self.assertGreater(response1.data['user_id'], 0)
        self.assertGreater(response2.data['user_id'], 0)

    @override_settings(DEBUG=True, ENABLE_DEV_TELEGRAM_AUTH=True, TELEGRAM_BOT_TOKEN="test-bot-token")
    def test_url_contains_encoded_init_data(self):
        """Generated URL should contain properly encoded initData."""
        response = self.client.post(
            self.url,
            {
                'first_name': 'TestUser',
                'username': 'testuser',
                'referral_code': self.referrer.referral_code,
            },
            format='json',
        )
        
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        
        url = response.data['url']
        init_data = response.data['init_data']
        
        # URL should contain the hash parameter
        self.assertIn('#tgWebAppData=', url)
        self.assertIn('tgWebAppVersion=7.0', url)
        self.assertIn('tgWebAppPlatform=weba', url)
        
        # init_data should contain required fields
        self.assertIn('user=', init_data)
        self.assertIn('auth_date=', init_data)
        self.assertIn('start_param=' + self.referrer.referral_code, init_data)
        self.assertIn('hash=', init_data)

    @override_settings(DEBUG=True, ENABLE_DEV_TELEGRAM_AUTH=True, TELEGRAM_BOT_TOKEN="test-bot-token")
    def test_init_data_contains_user_details(self):
        """Generated initData should contain the provided user details."""
        response = self.client.post(
            self.url,
            {
                'first_name': 'TestUser',
                'username': 'testuser',
                'referral_code': self.referrer.referral_code,
            },
            format='json',
        )
        
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        
        init_data = response.data['init_data']
        
        # Decode the user data from init_data
        # The user data is URL-encoded JSON
        self.assertIn('TestUser', init_data)
        self.assertIn('testuser', init_data)