# Test Utilities for I Ching Application
# Helper functions for setting up test data and admin users

from django.contrib.auth import get_user_model
from django.contrib.auth.models import Permission
from django.contrib.contenttypes.models import ContentType
import logging

User = get_user_model()
logger = logging.getLogger(__name__)


def create_admin_with_report_permissions(
    phone='13800000001',
    email='test_admin@example.com',
    first_name='Test',
    last_name='Admin',
    password='testpassword123'
):
    """
    Create an admin user with report notification permissions.
    
    This function creates a staff user with the 'can_receive_ai_report_emails'
    permission required to receive AI analysis report notifications.
    
    Args:
        phone (str): Phone number for the admin user
        email (str): Email address for the admin user (required for notifications)
        first_name (str): First name
        last_name (str): Last name
        password (str): Password for the user
    
    Returns:
        User: Created admin user with permissions
    """
    # Create admin user
    admin_user = User.objects.create_user(
        phone=phone,
        email=email,
        first_name=first_name,
        last_name=last_name,
        password=password,
        is_staff=True,
        is_active=True
    )
    
    # Get the correct content type for User model
    user_content_type = ContentType.objects.get_for_model(User)
    
    # Get or create the report permission with correct content type
    permission, created = Permission.objects.get_or_create(
        codename='can_receive_ai_report_emails',
        defaults={
            'name': 'Can receive AI analysis report emails',
            'content_type': user_content_type
        }
    )
    
    # Add permission to admin user
    admin_user.user_permissions.add(permission)
    
    return admin_user


def debug_permission_system():
    """
    Debug function to understand permission system issues.
    
    Returns:
        dict: Debug information about permissions and users
    """
    debug_info = {}
    
    # Check all permissions with the codename
    permissions = Permission.objects.filter(codename='can_receive_ai_report_emails')
    debug_info['permissions_found'] = permissions.count()
    debug_info['permission_details'] = []
    
    for perm in permissions:
        debug_info['permission_details'].append({
            'id': perm.id,
            'codename': perm.codename,
            'name': perm.name,
            'content_type_id': perm.content_type_id,
            'content_type': str(perm.content_type)
        })
    
    # Check all staff users
    staff_users = User.objects.filter(is_staff=True, is_active=True)
    debug_info['staff_users_count'] = staff_users.count()
    debug_info['staff_user_details'] = []
    
    for user in staff_users:
        user_perms = user.user_permissions.all()
        debug_info['staff_user_details'].append({
            'id': user.id,
            'email': user.email,
            'phone': user.phone,
            'is_staff': user.is_staff,
            'is_active': user.is_active,
            'permissions_count': user_perms.count(),
            'has_report_permission': user.user_permissions.filter(
                codename='can_receive_ai_report_emails'
            ).exists()
        })
    
    # Test the actual function
    from api.utils import get_report_recipients
    debug_info['recipients'] = get_report_recipients()
    
    return debug_info


def create_admin_with_management_permissions(
    phone='13800000002',
    email='test_manager@example.com',
    first_name='Test',
    last_name='Manager',
    password='testpassword123'
):
    """
    Create an admin user with report management permissions.
    
    This function creates a staff user with both report notification and
    management permissions.
    
    Args:
        phone (str): Phone number for the admin user
        email (str): Email address for the admin user
        first_name (str): First name
        last_name (str): Last name
        password (str): Password for the user
    
    Returns:
        User: Created admin user with management permissions
    """
    # Create admin user
    admin_user = User.objects.create_user(
        phone=phone,
        email=email,
        first_name=first_name,
        last_name=last_name,
        password=password,
        is_staff=True,
        is_active=True,
        is_superuser=True  # For full admin access
    )
    
    # Get the correct content type for User model
    user_content_type = ContentType.objects.get_for_model(User)
    
    # Get or create the report permissions
    report_permission, _ = Permission.objects.get_or_create(
        codename='can_receive_ai_report_emails',
        defaults={
            'name': 'Can receive AI analysis report emails',
            'content_type': user_content_type
        }
    )
    
    manage_permission, _ = Permission.objects.get_or_create(
        codename='can_manage_ai_reports',
        defaults={
            'name': 'Can manage and resolve AI analysis reports',
            'content_type': user_content_type
        }
    )
    
    # Add permissions to admin user
    admin_user.user_permissions.add(report_permission, manage_permission)
    
    return admin_user


def setup_test_permissions():
    """
    Set up all necessary permissions for testing.
    
    This function ensures all required permissions exist in the test database.
    Call this in test setUp methods if you need to ensure permissions exist.
    
    Returns:
        dict: Dictionary containing created permissions
    """
    user_content_type = ContentType.objects.get_for_model(User)
    
    permissions = {}
    
    # Report notification permission
    permissions['report_emails'], _ = Permission.objects.get_or_create(
        codename='can_receive_ai_report_emails',
        defaults={
            'name': 'Can receive AI analysis report emails',
            'content_type': user_content_type
        }
    )
    
    # Report management permission
    permissions['manage_reports'], _ = Permission.objects.get_or_create(
        codename='can_manage_ai_reports',
        defaults={
            'name': 'Can manage and resolve AI analysis reports',
            'content_type': user_content_type
        }
    )
    
    return permissions


def create_test_bazi_person(user=None, name="Test Person"):
    """
    Create a test BaZi person for testing purposes.
    
    Args:
        user (User): User to associate with the person (optional)
        name (str): Name for the person
    
    Returns:
        Person: Created BaZi person instance
    """
    from bazi.models import Person
    from datetime import date, time
    
    return Person.objects.create(
        name=name,
        birth_date=date(1990, 5, 15),
        birth_time=time(14, 30),
        gender="M",
        created_by=user,
        owner=True if user else False
    )


def create_test_liuyao(user=None, question="Test Question"):
    """
    Create a test LiuYao for testing purposes.
    
    Args:
        user (User): User to associate with the LiuYao (optional)
        question (str): Question for the divination
    
    Returns:
        liuyao: Created LiuYao instance
    """
    from liuyao.models import liuyao
    from django.utils import timezone
    
    return liuyao.objects.create(
        question=question,
        qdate=timezone.now(),
        user=user,
        y1="1",
        y2="0",
        y3="1",
        y4="000",
        y5="0",
        y6="1",
        data="{}"  # Empty JSON data for testing
    )


class ReportTestMixin:
    """
    Mixin class for tests that need report functionality.
    
    Provides common setup methods for testing report features.
    """
    
    def setUp_report_admin(self):
        """Set up admin user with report permissions for testing"""
        self.admin_user = create_admin_with_report_permissions(
            email='test_admin@example.com'
        )
        self.permissions = setup_test_permissions()
    
    def setUp_report_manager(self):
        """Set up admin user with management permissions for testing"""
        self.manager_user = create_admin_with_management_permissions(
            email='test_manager@example.com'
        )
        self.permissions = setup_test_permissions()
    
    def setUp_test_data(self):
        """Set up test data for reporting tests"""
        # Create regular user
        self.test_user = User.objects.create_user(
            phone='13800000100',
            email='test_user@example.com',
            first_name='Test',
            last_name='User',
            password='testpassword123'
        )
        
        # Create test BaZi person
        self.test_person = create_test_bazi_person(
            user=self.test_user,
            name="Test Person for Reports"
        )
        
        # Create test LiuYao
        self.test_liuyao = create_test_liuyao(
            user=self.test_user,
            question="Test Question for Reports"
        )


def cleanup_test_permissions():
    """
    Clean up test permissions after testing.
    
    Call this in test tearDown methods to clean up permissions.
    """
    Permission.objects.filter(
        codename__in=['can_receive_ai_report_emails', 'can_manage_ai_reports']
    ).delete()


# Example usage for your test files:
"""
from tests.test_utils import ReportTestMixin, create_admin_with_report_permissions

class YourTestCase(TestCase, ReportTestMixin):
    def setUp(self):
        super().setUp()
        # This will create an admin with report permissions
        self.setUp_report_admin()
        # Or create test data
        self.setUp_test_data()
    
    def test_your_functionality(self):
        # Now you have self.admin_user with proper permissions
        # and self.test_person, self.test_liuyao for testing
        pass
"""