from django.contrib import admin
from django.utils.translation import gettext_lazy as _
from django.utils.html import format_html
from django import forms
from django.urls import path, reverse
from django.http import JsonResponse
from django.utils.safestring import mark_safe
from django.contrib.admin.views.main import ChangeList
from django.db.models import Q
from django.utils import timezone
from django.template.response import TemplateResponse
from .models import PromptTemplate, PromptPlaceholder, AIProviderConfig, ConversationConfig, AdminAIAnalysis, Conversation, Message
from .utils.template_validation import validate_template, get_template_statistics
from .utils.admin_llm import run_admin_llm_inference
from django.core.exceptions import PermissionDenied
import json

class PromptTemplateAdminForm(forms.ModelForm):
    """
    Form for the PromptTemplate admin with a custom widget for the content field
    """
    class Meta:
        model = PromptTemplate
        fields = '__all__'
        widgets = {
            'content': forms.Textarea(attrs={'rows': 30, 'style': 'font-family: monospace;'}),
        }

@admin.register(PromptTemplate)
class PromptTemplateAdmin(admin.ModelAdmin):
    form = PromptTemplateAdminForm
    list_display = ('name', 'divination_type', 'language', 'status', 'colored_status', 'validation_status', 'created_by', 'updated_at')
    list_filter = ('divination_type', 'language', 'status', 'created_by')
    search_fields = ('name', 'description', 'content')
    readonly_fields = ('created_at', 'updated_at', 'last_validated', 'validation_warnings_display')
    actions = ['validate_selected_templates']
    fieldsets = (
        (None, {
            'fields': ('name', 'description', 'divination_type', 'language', 'status')
        }),
        (_('Content'), {
            'fields': ('content',),
            'classes': ('wide',),
        }),
        (_('Validation'), {
            'fields': ('validation_warnings_display', 'last_validated'),
            'classes': ('collapse',),
        }),
        (_('History'), {
            'fields': ('created_by', 'created_at', 'modified_by', 'updated_at'),
            'classes': ('collapse',),
        }),
    )
    save_on_top = True

    def colored_status(self, obj):
        """Return colored status indicator"""
        colors = {
            'draft': 'orange',
            'active': 'green',
            'archived': 'gray',
        }
        return format_html(
            '<span style="color: {};">{}</span>',
            colors.get(obj.status, 'black'),
            obj.get_status_display()
        )
    colored_status.short_description = _('Status')
    
    def validation_status(self, obj):
        """Return colored validation status indicator"""
        if not obj.validation_warnings:
            return format_html('<span style="color: green;">✓ Valid</span>')
        elif obj.status == 'active':
            return format_html('<span style="color: red;">⚠ Invalid</span>')
        else:
            return format_html('<span style="color: orange;">⚠ Warnings</span>')
    validation_status.short_description = _('Validation')
    
    def validation_warnings_display(self, obj):
        """Display validation warnings in a formatted way"""
        if not obj.validation_warnings:
            return _('No validation warnings')
        
        warnings = obj.validation_warnings
        if isinstance(warnings, list):
            return format_html(
                '<ul style="color: red;">{}</ul>',
                ''.join(f'<li>{warning}</li>' for warning in warnings)
            )
        return str(warnings)
    validation_warnings_display.short_description = _('Validation Warnings')
    
    def save_model(self, request, obj, form, change):
        """Override save_model to set created_by and modified_by"""
        if not obj.id:
            obj.created_by = request.user
        obj.modified_by = request.user
        super().save_model(request, obj, form, change)
    
    def validate_selected_templates(self, request, queryset):
        """Admin action to validate selected templates"""
        for template in queryset:
            is_valid, warnings = template.validate()
            if is_valid:
                self.message_user(request, f'Template "{template.name}" is valid')
            else:
                self.message_user(
                    request,
                    f'Template "{template.name}" has warnings: {", ".join(warnings)}',
                    level='warning'
                )
    validate_selected_templates.short_description = _('Validate selected templates')
    
    def get_urls(self):
        urls = super().get_urls()
        custom_urls = [
            path(
                '<int:template_id>/validate/',
                self.admin_site.admin_view(self.validate_template_view),
                name='ai_prompttemplate_validate',
            ),
        ]
        return custom_urls + urls
    
    def validate_template_view(self, request, template_id):
        """AJAX view for validating a template"""
        try:
            template = self.model.objects.get(pk=template_id)
            is_valid, warnings = template.validate()
            
            # Get template statistics
            stats = template.get_statistics()
            
            return JsonResponse({
                'success': True,
                'is_valid': is_valid,
                'warnings': warnings,
                'statistics': stats,
            })
        except self.model.DoesNotExist:
            return JsonResponse({
                'success': False,
                'error': _('Template not found')
            }, status=404)
        except Exception as e:
            return JsonResponse({
                'success': False,
                'error': str(e)
            }, status=500)
    
    class Media:
        css = {
            'all': ('css/admin/prompttemplate.css',)
        }
        js = ('js/admin/prompttemplate.js',)

@admin.register(PromptPlaceholder)
class PromptPlaceholderAdmin(admin.ModelAdmin):
    list_display = ('name', 'divination_type', 'description_short')
    list_filter = ('divination_type',)
    search_fields = ('name', 'description')
    
    def description_short(self, obj):
        """Return shortened description"""
        if len(obj.description) > 50:
            return obj.description[:50] + '...'
        return obj.description
    description_short.short_description = _('Description')

class AIProviderConfigAdminForm(forms.ModelForm):
    """
    Custom form for AIProviderConfig with dynamic model choices based on provider
    """
    class Meta:
        model = AIProviderConfig
        fields = '__all__'
    
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        
        # Start with basic choices - JavaScript will populate the full list
        initial_choices = [('', '---------')]
        
        # If we're editing an existing instance, preserve the current model value
        if self.instance and self.instance.pk and self.instance.model:
            # Get the friendly name for the current model if available
            current_model = self.instance.model
            model_choices = AIProviderConfig.get_available_models(self.instance.provider)
            friendly_name = None
            
            for model_code, model_name in model_choices:
                if model_code == current_model:
                    friendly_name = model_name
                    break
            
            # Add the current model to the choices so it's preserved
            display_name = friendly_name if friendly_name else current_model
            initial_choices.append((current_model, display_name))
        
        self.fields['model'].widget = forms.Select(choices=initial_choices)
        self.fields['model'].required = True

@admin.register(AIProviderConfig)
class AIProviderConfigAdmin(admin.ModelAdmin):
    form = AIProviderConfigAdminForm
    list_display = ('divination_type', 'provider', 'model_display', 'is_active', 'updated_at', 'modified_by')
    list_filter = ('provider', 'is_active', 'divination_type')
    search_fields = ('divination_type', 'model')
    readonly_fields = ('created_at', 'updated_at')
    actions = ['activate_configs', 'deactivate_configs']
    fieldsets = (
        (None, {
            'fields': ('divination_type', 'provider', 'model', 'is_active'),
            'description': _('Configure AI provider and model for each divination type. Separate configurations are available for analysis (BaZi, LiuYao, Number) and conversations (BaZi Conversation, LiuYao Conversation). Only one configuration per divination type can be active.')
        }),
        (_('History'), {
            'fields': ('created_by', 'created_at', 'modified_by', 'updated_at'),
            'classes': ('collapse',),
        }),
    )
    
    def model_display(self, obj):
        """Display model with friendly name if available"""
        model_choices = AIProviderConfig.get_available_models(obj.provider)
        for model_code, model_name in model_choices:
            if model_code == obj.model:
                return format_html('<span title="{}">{}</span>', model_name, obj.model)
        return obj.model
    model_display.short_description = _('Model')
    
    def save_model(self, request, obj, form, change):
        """Override save_model to set created_by and modified_by"""
        if not obj.id:
            obj.created_by = request.user
        obj.modified_by = request.user
        super().save_model(request, obj, form, change)
    
    def activate_configs(self, request, queryset):
        """Admin action to activate selected configurations"""
        updated = queryset.update(is_active=True)
        self.message_user(request, f'{updated} configuration(s) were activated.')
    activate_configs.short_description = _('Activate selected configurations')
    
    def deactivate_configs(self, request, queryset):
        """Admin action to deactivate selected configurations"""
        updated = queryset.update(is_active=False)
        self.message_user(request, f'{updated} configuration(s) were deactivated.')
    deactivate_configs.short_description = _('Deactivate selected configurations')
    
    def change_view(self, request, object_id, form_url='', extra_context=None):
        """Override change_view to add model choices to context"""
        extra_context = extra_context or {}
        
        # Add all provider model choices to context for JavaScript
        provider_models = {}
        for provider_code, provider_name in AIProviderConfig.PROVIDER_CHOICES:
            provider_models[provider_code] = AIProviderConfig.get_available_models(provider_code)
        
        extra_context['provider_models_json'] = json.dumps(provider_models)
        return super().change_view(request, object_id, form_url, extra_context)
    
    def add_view(self, request, form_url='', extra_context=None):
        """Override add_view to add model choices to context"""
        extra_context = extra_context or {}
        
        # Add all provider model choices to context for JavaScript
        provider_models = {}
        for provider_code, provider_name in AIProviderConfig.PROVIDER_CHOICES:
            provider_models[provider_code] = AIProviderConfig.get_available_models(provider_code)
        
        extra_context['provider_models_json'] = json.dumps(provider_models)
        return super().add_view(request, form_url, extra_context)
    
    class Media:
        js = ('js/admin/aiproviderconfig.js',)

@admin.register(ConversationConfig)
class ConversationConfigAdmin(admin.ModelAdmin):
    """Admin interface for Conversation Configuration"""
    list_display = ('max_messages', 'is_active', 'updated_at', 'modified_by')
    list_filter = ('is_active',)
    readonly_fields = ('created_at', 'updated_at')
    fieldsets = (
        (None, {
            'fields': ('max_messages', 'is_active'),
            'description': _('Configure conversation limits. Only one configuration can be active at a time.')
        }),
        (_('History'), {
            'fields': ('created_by', 'created_at', 'modified_by', 'updated_at'),
            'classes': ('collapse',),
        }),
    )
    
    def save_model(self, request, obj, form, change):
        """Override save_model to set created_by and modified_by"""
        if not obj.id:
            obj.created_by = request.user
        obj.modified_by = request.user
        super().save_model(request, obj, form, change)
    
    def has_delete_permission(self, request, obj=None):
        """Prevent deletion if it's the only active config"""
        if obj and obj.is_active:
            active_count = ConversationConfig.objects.filter(is_active=True).count()
            if active_count <= 1:
                return False
        return super().has_delete_permission(request, obj)

class AdminAIAnalysisAdminForm(forms.ModelForm):
    """
    Custom form for AdminAIAnalysis with dynamic model choices based on provider
    """
    class Meta:
        model = AdminAIAnalysis
        fields = '__all__'
    
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        
        # Start with basic choices - JavaScript will populate the full list
        initial_choices = [('', '---------')]
        
        # If we're editing an existing instance, preserve the current model value
        if self.instance and self.instance.pk and self.instance.model:
            # Get the friendly name for the current model if available
            current_model = self.instance.model
            model_choices = AIProviderConfig.get_available_models(self.instance.provider)
            friendly_name = None
            
            for model_code, model_name in model_choices:
                if model_code == current_model:
                    friendly_name = model_name
                    break
            
            # Add the current model to the choices so it's preserved
            display_name = friendly_name if friendly_name else current_model
            initial_choices.append((current_model, display_name))
        
        self.fields['model'].widget = forms.Select(choices=initial_choices)
        self.fields['model'].required = True
        
        # Add custom CSS classes for JavaScript targeting
        self.fields['provider'].widget.attrs.update({'class': 'provider-select'})
        self.fields['model'].widget.attrs.update({'class': 'model-select'})

@admin.register(AdminAIAnalysis)
class AdminAIAnalysisAdmin(admin.ModelAdmin):
    form = AdminAIAnalysisAdminForm
    list_display = ('title', 'provider', 'model', 'status', 'created_by', 'created_at')
    search_fields = ('title', 'prompt', 'response')
    list_filter = ('provider', 'model', 'status', 'created_at')
    readonly_fields = ('response', 'status', 'created_by', 'created_at', 'updated_at')
    fieldsets = (
        (None, {
            'fields': ('title', 'prompt', 'provider', 'model')
        }),
        (_('Results'), {
            'fields': ('response', 'status', 'meta'),
            'classes': ('collapse',),
        }),
        (_('History'), {
            'fields': ('created_by', 'created_at', 'updated_at'),
            'classes': ('collapse',),
        }),
    )

    def has_module_permission(self, request):
        return request.user.has_perm('ai.can_send_admin_llm_analysis')

    def has_view_permission(self, request, obj=None):
        return request.user.has_perm('ai.can_send_admin_llm_analysis')

    def has_add_permission(self, request):
        return request.user.has_perm('ai.can_send_admin_llm_analysis')

    def has_change_permission(self, request, obj=None):
        return request.user.has_perm('ai.can_send_admin_llm_analysis')

    def save_model(self, request, obj, form, change):
        if not obj.created_by:
            obj.created_by = request.user
        super().save_model(request, obj, form, change)
        
        # If status is pending, send to LLM
        if obj.status == 'pending':
            run_admin_llm_inference(obj)
    
    def get_urls(self):
        """Add custom URLs for AJAX endpoints"""
        urls = super().get_urls()
        custom_urls = [
            path(
                'get-models/<str:provider>/',
                self.admin_site.admin_view(self.get_models_view),
                name='ai_adminaianalysis_get_models',
            ),
        ]
        return custom_urls + urls
    
    def get_models_view(self, request, provider):
        """AJAX view to get available models for a provider"""
        try:
            model_choices = AIProviderConfig.get_available_models(provider)
            return JsonResponse({
                'success': True,
                'models': [{'id': code, 'name': name} for code, name in model_choices]
            })
        except Exception as e:
            return JsonResponse({
                'success': False,
                'error': str(e)
            }, status=400)
    
    def change_view(self, request, object_id, form_url='', extra_context=None):
        """Override change_view to add model choices to context"""
        extra_context = extra_context or {}
        
        # Add all provider model choices to context for JavaScript
        provider_models = {}
        for provider_code, provider_name in AIProviderConfig.PROVIDER_CHOICES:
            provider_models[provider_code] = AIProviderConfig.get_available_models(provider_code)
        
        extra_context['provider_models_json'] = json.dumps(provider_models)
        return super().change_view(request, object_id, form_url, extra_context)
    
    def add_view(self, request, form_url='', extra_context=None):
        """Override add_view to add model choices to context"""
        extra_context = extra_context or {}
        
        # Add all provider model choices to context for JavaScript
        provider_models = {}
        for provider_code, provider_name in AIProviderConfig.PROVIDER_CHOICES:
            provider_models[provider_code] = AIProviderConfig.get_available_models(provider_code)
        
        extra_context['provider_models_json'] = json.dumps(provider_models)
        return super().add_view(request, form_url, extra_context)
    
    class Media:
        js = ('js/admin/adminaianalysis.js',)


# Centralized AI Reports Admin Interface
class AIReportProxy:
    """Virtual model to represent reports from all analysis types"""
    def __init__(self, obj, analysis_type, prefix=''):
        self.obj = obj
        self.analysis_type = analysis_type
        self.prefix = prefix
        
        # Common fields
        self.id = f"{analysis_type}_{obj.id}"
        self.user = getattr(obj, 'created_by', None) or getattr(obj, 'user', None)
        self.created_at = getattr(obj, 'created_at', None)
        
        # Report fields with prefix handling
        self.reported = getattr(obj, f'{prefix}analysis_reported', False)
        self.report_category = getattr(obj, f'{prefix}report_category', '')
        self.report_message = getattr(obj, f'{prefix}report_message', '')
        self.report_timestamp = getattr(obj, f'{prefix}report_timestamp', None)
        self.report_status = getattr(obj, f'{prefix}report_status', '')
        self.report_admin_notes = getattr(obj, f'{prefix}report_admin_notes', '')
# Removed admin_action field as it's been simplified
        self.report_resolved_by = getattr(obj, f'{prefix}report_resolved_by', None)
        self.report_resolved_at = getattr(obj, f'{prefix}report_resolved_at', None)
        
        # Analysis specific data
        if analysis_type == 'bazi':
            self.name = obj.name
            self.birth_date = obj.birth_date
        elif analysis_type == 'number':
            self.name = obj.name 
            self.birth_date = obj.birth_date
        elif analysis_type == 'liuyao':
            self.name = obj.question[:50] + ('...' if len(obj.question) > 50 else '')
            self.birth_date = obj.qdate
    
    class Meta:
        verbose_name = 'AI Analysis Report'
        verbose_name_plural = 'AI Analysis Reports'


class AIReportsChangeList(ChangeList):
    """Custom ChangeList for AI Reports"""
    def get_results(self, request):
        # Get reports from all three analysis types
        from bazi.models import Person
        from liuyao.models import liuyao
        
        reports = []
        
        # BaZi reports
        bazi_reports = Person.objects.filter(bazi_analysis_reported=True).select_related('created_by', 'bazi_report_resolved_by')
        for person in bazi_reports:
            reports.append(AIReportProxy(person, 'bazi', 'bazi_'))
            
        # Number reports  
        number_reports = Person.objects.filter(number_analysis_reported=True).select_related('created_by', 'number_report_resolved_by')
        for person in number_reports:
            reports.append(AIReportProxy(person, 'number', 'number_'))
            
        # LiuYao reports
        liuyao_reports = liuyao.objects.filter(analysis_reported=True).select_related('user', 'report_resolved_by')
        for entry in liuyao_reports:
            reports.append(AIReportProxy(entry, 'liuyao', ''))
        
        # Sort by report timestamp (newest first)
        reports.sort(key=lambda x: x.report_timestamp or timezone.datetime.min.replace(tzinfo=timezone.utc), reverse=True)
        
        # Apply filtering
        status_filter = request.GET.get('report_status__exact')
        if status_filter:
            reports = [r for r in reports if r.report_status == status_filter]
            
        category_filter = request.GET.get('report_category__exact')
        if category_filter:
            reports = [r for r in reports if r.report_category == category_filter]
            
        analysis_type_filter = request.GET.get('analysis_type__exact')
        if analysis_type_filter:
            reports = [r for r in reports if r.analysis_type == analysis_type_filter]
        
        self.result_list = reports
        self.result_count = len(reports)
        self.full_result_count = len(reports)


class AIReportsAdmin(admin.ModelAdmin):
    """Centralized admin interface for all AI analysis reports"""
    
    # Use default admin template for now
    # change_list_template = 'admin/ai/aireports_change_list.html'
    
    list_display = ('report_id', 'analysis_type_display', 'user_display', 'name_display', 'category_display', 'status_display', 'report_timestamp', 'admin_action_buttons')
    # Remove list_filter since we use custom ChangeList
    list_filter = []
    # Remove search_fields since we use custom ChangeList  
    search_fields = []
    actions = ['mark_as_reviewed', 'mark_as_resolved', 'mark_as_dismissed']
    
    def has_add_permission(self, request):
        """Reports are created by users, not admins"""
        return False
    
    def has_delete_permission(self, request, obj=None):
        """Reports should not be deleted, only resolved"""
        return False
    
    def has_change_permission(self, request, obj=None):
        """Reports are read-only in this view"""
        return False
    
    def get_changelist(self, request, **kwargs):
        """Use custom ChangeList"""
        return AIReportsChangeList
    
    def get_queryset(self, request):
        """Return empty queryset since we handle this in ChangeList"""
        # Return empty list since we use custom ChangeList for data retrieval
        return []
    
    def report_id(self, obj):
        """Display report ID"""
        return obj.id
    report_id.short_description = 'Report ID'
    
    def analysis_type_display(self, obj):
        """Display analysis type with icon"""
        icons = {
            'bazi': '🔮',
            'number': '🔢', 
            'liuyao': '☯️'
        }
        names = {
            'bazi': 'BaZi',
            'number': 'Number',
            'liuyao': 'LiuYao'
        }
        return format_html('{} {}', icons.get(obj.analysis_type, ''), names.get(obj.analysis_type, obj.analysis_type))
    analysis_type_display.short_description = 'Analysis Type'
    
    def user_display(self, obj):
        """Display user information"""
        if not obj.user:
            return 'Unknown User'
        
        full_name = f"{obj.user.first_name} {obj.user.last_name}".strip()
        if not full_name:
            full_name = "No Name"
        
        return format_html(
            '<strong>{}</strong><br><small style="color: #666;">{}</small>',
            full_name,
            obj.user.phone
        )
    user_display.short_description = 'User'
    
    def name_display(self, obj):
        """Display name/question"""
        return obj.name
    name_display.short_description = 'Name/Question'
    
    def category_display(self, obj):
        """Display report category with color coding"""
        category_colors = {
            'inappropriate_content': '#dc3545',
            'inaccurate_analysis': '#fd7e14', 
            'offensive_language': '#dc3545',
            'technical_error': '#6610f2',
            'other': '#6c757d'
        }
        category_names = {
            'inappropriate_content': '内容不当',
            'inaccurate_analysis': '分析不准确',
            'offensive_language': '语言冒犯', 
            'technical_error': '技术错误',
            'other': '其他'
        }
        
        color = category_colors.get(obj.report_category, '#6c757d')
        name = category_names.get(obj.report_category, obj.report_category)
        
        return format_html('<span style="color: {}; font-weight: bold;">{}</span>', color, name)
    category_display.short_description = 'Category'
    
    def status_display(self, obj):
        """Display report status with color coding"""
        if obj.report_status == 'pending':
            return format_html('<span style="color: orange; font-weight: bold;">⏳ 待处理</span>')
        elif obj.report_status == 'reviewed':
            return format_html('<span style="color: blue; font-weight: bold;">👁️ 已审核</span>')
        elif obj.report_status == 'resolved':
            return format_html('<span style="color: green; font-weight: bold;">✅ 已解决</span>')
        elif obj.report_status == 'dismissed':
            return format_html('<span style="color: gray; font-weight: bold;">❌ 已忽略</span>')
        else:
            return format_html('<span style="color: red;">🚩 已举报</span>')
    status_display.short_description = 'Status'
    
    def admin_action_buttons(self, obj):
        """Display action buttons for quick actions"""
        if obj.report_status in ['resolved', 'dismissed']:
            return format_html('<span style="color: #666; font-style: italic;">已处理</span>')
        
        # Generate URLs to the original objects
        if obj.analysis_type == 'bazi':
            change_url = reverse('admin:bazi_person_change', args=[obj.obj.id])
        elif obj.analysis_type == 'number':
            change_url = reverse('admin:bazi_person_change', args=[obj.obj.id])
        elif obj.analysis_type == 'liuyao':
            change_url = reverse('admin:liuyao_liuyao_change', args=[obj.obj.id])
        else:
            change_url = '#'
        
        return format_html(
            '<a href="{}" class="button" style="background-color: #007cba; color: white; padding: 4px 8px; text-decoration: none; border-radius: 3px; font-size: 11px; margin-right: 5px;">查看详情</a>',
            change_url
        )
    admin_action_buttons.short_description = 'Actions'
    
    # Admin actions
    def mark_as_reviewed(self, request, queryset):
        """Mark selected reports as reviewed"""
        # Since queryset contains proxy objects, we need to handle each type separately
        count = 0
        for report in queryset:
            if report.report_status == 'pending':
                if report.analysis_type in ['bazi', 'number']:
                    field_prefix = f'{report.analysis_type}_' if report.analysis_type == 'bazi' else 'number_'
                    setattr(report.obj, f'{field_prefix}report_status', 'reviewed')
                    report.obj.save(update_fields=[f'{field_prefix}report_status'])
                elif report.analysis_type == 'liuyao':
                    report.obj.report_status = 'reviewed'
                    report.obj.save(update_fields=['report_status'])
                count += 1
        
        self.message_user(request, f'{count} 个举报已标记为已审核')
    mark_as_reviewed.short_description = "标记为已审核"
    
    def mark_as_resolved(self, request, queryset):
        """Mark selected reports as resolved"""
        count = 0
        for report in queryset:
            if report.report_status == 'pending':
                if report.analysis_type in ['bazi', 'number']:
                    field_prefix = f'{report.analysis_type}_' if report.analysis_type == 'bazi' else 'number_'
                    setattr(report.obj, f'{field_prefix}report_status', 'resolved')
                    setattr(report.obj, f'{field_prefix}report_resolved_by', request.user)
                    setattr(report.obj, f'{field_prefix}report_resolved_at', timezone.now())
                    report.obj.save(update_fields=[
                        f'{field_prefix}report_status',
                        f'{field_prefix}report_resolved_by', f'{field_prefix}report_resolved_at',
                        f'{field_prefix}report_resolution_email_sent'
                    ])
                elif report.analysis_type == 'liuyao':
                    report.obj.report_status = 'resolved'
                    report.obj.report_resolved_by = request.user
                    report.obj.report_resolved_at = timezone.now()
                    report.obj.save(update_fields=[
                        'report_status',
                        'report_resolved_by', 'report_resolved_at',
                        'report_resolution_email_sent'
                    ])
                
                # Send notification email to user (only if not already sent)
                email_sent_field = f'{field_prefix}report_resolution_email_sent' if report.analysis_type in ['bazi', 'number'] else 'report_resolution_email_sent'
                if not getattr(report.obj, email_sent_field, False):
                    try:
                        from api.utils import send_user_resolution_notification
                        if report.user and report.user.email:
                            send_user_resolution_notification(
                                report.user, report.obj, report.analysis_type, 'resolved', report.report_admin_notes
                            )
                            setattr(report.obj, email_sent_field, True)
                    except Exception as e:
                        self.message_user(request, f"举报已解决但邮件发送失败: {str(e)}")
                
                count += 1
        
        self.message_user(request, f'{count} 个举报已解决')
    mark_as_resolved.short_description = "标记为已解决"
    
    def mark_as_dismissed(self, request, queryset):
        """Mark selected reports as dismissed"""
        count = 0
        for report in queryset:
            if report.report_status == 'pending':
                if report.analysis_type in ['bazi', 'number']:
                    field_prefix = f'{report.analysis_type}_' if report.analysis_type == 'bazi' else 'number_'
                    setattr(report.obj, f'{field_prefix}report_status', 'dismissed')
                    setattr(report.obj, f'{field_prefix}report_resolved_by', request.user)
                    setattr(report.obj, f'{field_prefix}report_resolved_at', timezone.now())
                    report.obj.save(update_fields=[
                        f'{field_prefix}report_status',
                        f'{field_prefix}report_resolved_by', f'{field_prefix}report_resolved_at'
                    ])
                elif report.analysis_type == 'liuyao':
                    report.obj.report_status = 'dismissed'
                    report.obj.report_resolved_by = request.user
                    report.obj.report_resolved_at = timezone.now()
                    report.obj.save(update_fields=[
                        'report_status',
                        'report_resolved_by', 'report_resolved_at'
                    ]                    )
                
                # No email notification for dismissed reports (only for resolved)
                
                count += 1
        
        self.message_user(request, f'{count} 个举报已忽略')
    mark_as_dismissed.short_description = "忽略举报"


# Extend the admin site with custom functionality
from django.contrib.admin import AdminSite

class CustomAdminSite(AdminSite):
    """Custom admin site with additional features for AI reports"""
    
    def get_app_list(self, request, app_label=None):
        """Add custom AI Reports section to admin"""
        app_list = super().get_app_list(request, app_label)
        
        # Add custom AI Reports section
        ai_reports_app = {
            'name': 'AI Analysis Reports',
            'app_label': 'ai_reports',
            'models': [
                {
                    'name': 'All BaZi Reports',
                    'object_name': 'BaziReport',
                    'admin_url': '/admin/bazi/person/?bazi_analysis_reported__exact=1',
                    'add_url': None,
                    'view_only': True,
                },
                {
                    'name': 'All Number Reports', 
                    'object_name': 'NumberReport',
                    'admin_url': '/admin/bazi/person/?number_analysis_reported__exact=1',
                    'add_url': None,
                    'view_only': True,
                },
                {
                    'name': 'All LiuYao Reports',
                    'object_name': 'LiuYaoReport', 
                    'admin_url': '/admin/liuyao/liuyao/?analysis_reported__exact=1',
                    'add_url': None,
                    'view_only': True,
                },
                {
                    'name': 'Pending Reports (All Types)',
                    'object_name': 'PendingReport',
                    'admin_url': '/admin/bazi/person/?bazi_report_status__exact=pending',
                    'add_url': None,
                    'view_only': True,
                },
            ]
        }
        
        # Insert the AI Reports app after the existing apps
        app_list.append(ai_reports_app)
        
        return app_list

# Create a proper model with complete meta for admin registration
from django.apps import apps

class AIReportProxyModel:
    """
    Model-like class for admin registration with complete meta attributes.
    """
    def __init__(self):
        pass
    
    def __str__(self):
        return 'AI Analysis Reports'

# Create a complete meta object with all required attributes
def create_meta():
    ai_app_config = apps.get_app_config('ai')
    
    meta = type('Meta', (), {
        'verbose_name': 'AI Analysis Report',
        'verbose_name_plural': 'AI Analysis Reports',
        'object_name': 'AIReportProxyModel',
        'app_label': 'ai',
        'model_name': 'aireportproxymodel',
        'app_config': ai_app_config,
        'abstract': False,
        'managed': False,
        'proxy': False,
        'swapped': None,
        'auto_created': False,
        'db_table': 'ai_report_proxy',
        'get_field': lambda self, name: None,
        'get_fields': lambda self: [],
        'concrete_fields': [],
        'local_fields': [],
        'many_to_many': [],
        'get_field_by_name': lambda self, name: (None, None, False, False),
    })()
    
    return meta

AIReportProxyModel._meta = create_meta()

# Override the admin to bypass all database operations
class AIReportsAdminFixed(AIReportsAdmin):
    """Fixed version that completely bypasses database operations"""
    
    # Override list_display to avoid field validation issues
    list_display = []
    list_filter = []
    search_fields = []
    
    def changelist_view(self, request, extra_context=None):
        """Override changelist_view to show reports summary with Django admin styling"""
        from bazi.models import Person
        from liuyao.models import liuyao
        
        # Get reports count
        bazi_count = Person.objects.filter(bazi_analysis_reported=True).count()
        number_count = Person.objects.filter(number_analysis_reported=True).count()
        liuyao_count = liuyao.objects.filter(analysis_reported=True).count()
        
        # Get pending counts
        pending_bazi = Person.objects.filter(bazi_report_status='pending').count()
        pending_number = Person.objects.filter(number_report_status='pending').count()
        pending_liuyao = liuyao.objects.filter(report_status='pending').count()
        
        # Get the admin site instance to provide proper navigation context
        from django.contrib.admin import site
        
        context = {
            'title': 'AI Analysis Reports',
            'subtitle': 'Centralized view of all AI analysis reports in the system',
            'app_label': 'ai',
            'opts': type('opts', (), {
                'app_label': 'ai',
                'model_name': 'aireportproxymodel',
                'verbose_name': 'AI Analysis Report',
                'verbose_name_plural': 'AI Analysis Reports',
                'object_name': 'AIReportProxyModel',
            })(),
            'has_view_permission': True,
            'has_add_permission': False,
            'has_change_permission': False,
            'has_delete_permission': False,
            # Add context needed for admin navigation
            'is_nav_sidebar_enabled': True,
            'available_apps': site.get_app_list(request),
            'site_header': site.site_header,
            'site_title': site.site_title,
            'index_title': site.index_title,
            'cl': type('FakeChangeList', (), {
                'result_count': bazi_count + number_count + liuyao_count,
                'full_result_count': bazi_count + number_count + liuyao_count,
            })(),
            'reports_summary': [
                {
                    'name': 'BaZi Reports',
                    'count': bazi_count,
                    'pending': pending_bazi,
                    'view_all_url': '/admin/bazi/person/?bazi_analysis_reported__exact=1',
                    'pending_url': '/admin/bazi/person/?bazi_report_status__exact=pending',
                },
                {
                    'name': 'Number Reports', 
                    'count': number_count,
                    'pending': pending_number,
                    'view_all_url': '/admin/bazi/person/?number_analysis_reported__exact=1',
                    'pending_url': '/admin/bazi/person/?number_report_status__exact=pending',
                },
                {
                    'name': 'LiuYao Reports',
                    'count': liuyao_count, 
                    'pending': pending_liuyao,
                    'view_all_url': '/admin/liuyao/liuyao/?analysis_reported__exact=1',
                    'pending_url': '/admin/liuyao/liuyao/?report_status__exact=pending',
                },
            ],
        }
        
        if extra_context:
            context.update(extra_context)
            
        return TemplateResponse(request, 'admin/ai/reports_dashboard.html', context)

# Register using the fixed admin class
admin.site._registry[AIReportProxyModel] = AIReportsAdminFixed(AIReportProxyModel, admin.site)

# Don't actually replace the admin site, just document the approach
# To implement this, you would need to modify settings.py:
# DJANGO_ADMIN_SITE = 'ai.admin.CustomAdminSite'


@admin.register(Conversation)
class ConversationAdmin(admin.ModelAdmin):
    """Admin interface for Conversation model"""
    list_display = ('id', 'title', 'user', 'person', 'message_count', 'created_at', 'updated_at')
    list_filter = ('created_at', 'updated_at')
    search_fields = ('title', 'user__phone', 'user__email', 'person__name')
    readonly_fields = ('created_at', 'updated_at', 'message_count_display')
    fieldsets = (
        (None, {
            'fields': ('user', 'person', 'title')
        }),
        (_('Statistics'), {
            'fields': ('message_count_display',),
            'classes': ('collapse',),
        }),
        (_('Timestamps'), {
            'fields': ('created_at', 'updated_at'),
            'classes': ('collapse',),
        }),
    )
    
    def message_count(self, obj):
        """Display message count"""
        return obj.get_message_count()
    message_count.short_description = _('Messages')
    
    def message_count_display(self, obj):
        """Display message count in detail view"""
        return obj.get_message_count()
    message_count_display.short_description = _('Total Messages')


@admin.register(Message)
class MessageAdmin(admin.ModelAdmin):
    """Admin interface for Message model"""
    list_display = ('id', 'conversation', 'role', 'content_preview', 'provider', 'model', 'created_at')
    list_filter = ('role', 'provider', 'created_at', 'conversation')
    search_fields = ('content', 'conversation__title', 'conversation__person__name')
    readonly_fields = ('created_at',)
    fieldsets = (
        (None, {
            'fields': ('conversation', 'role', 'content')
        }),
        (_('AI Metadata'), {
            'fields': ('provider', 'model', 'meta'),
            'classes': ('collapse',),
        }),
        (_('Timestamps'), {
            'fields': ('created_at',),
            'classes': ('collapse',),
        }),
    )
    
    def content_preview(self, obj):
        """Display content preview"""
        preview = obj.content[:100] + '...' if len(obj.content) > 100 else obj.content
        return preview
    content_preview.short_description = _('Content')