"""
Workflow Admin Configuration.

Django admin configuration for workflow models.
"""
from django.contrib import admin
from django.utils.html import format_html
from django.utils.translation import gettext_lazy as _

from .models import (
    ProcessDefinition,
    ProcessInstance,
    Task,
    TaskAssignment,
    ProcessVariable,
    ProcessHistory,
    SLADefinition,
    SLAViolation,
)


# =============================================================================
# Inline Admins
# =============================================================================

class TaskAssignmentInline(admin.TabularInline):
    """Inline admin for task assignments."""
    model = TaskAssignment
    extra = 0
    readonly_fields = ('assigned_at', 'unassigned_at')
    autocomplete_fields = ('user', 'group')


class ProcessVariableInline(admin.TabularInline):
    """Inline admin for process variables."""
    model = ProcessVariable
    extra = 0
    readonly_fields = ('created_at', 'updated_at')


class ProcessHistoryInline(admin.TabularInline):
    """Inline admin for process history."""
    model = ProcessHistory
    extra = 0
    readonly_fields = ('event_type', 'user', 'task', 'element_id', 'old_value', 'new_value', 'comment', 'created_at')
    can_delete = False

    def has_add_permission(self, request, obj=None):
        return False


class TaskInline(admin.TabularInline):
    """Inline admin for tasks."""
    model = Task
    extra = 0
    readonly_fields = ('created_at', 'claimed_at', 'completed_at')
    fields = ('name', 'task_type', 'status', 'assignee', 'priority', 'due_date', 'created_at')
    show_change_link = True


class SLADefinitionInline(admin.TabularInline):
    """Inline admin for SLA definitions."""
    model = SLADefinition
    extra = 0


# =============================================================================
# Model Admins
# =============================================================================

@admin.register(ProcessDefinition)
class ProcessDefinitionAdmin(admin.ModelAdmin):
    """Admin for ProcessDefinition model."""
    list_display = (
        'name',
        'slug',
        'version',
        'is_deployed',
        'is_active',
        'tenant',
        'created_by',
        'created_at',
    )
    list_filter = (
        'is_deployed',
        'is_active',
        'tenant',
        'created_at',
    )
    search_fields = (
        'name',
        'slug',
        'description',
    )
    readonly_fields = (
        'id',
        'created_at',
        'updated_at',
        'deployed_at',
    )
    autocomplete_fields = ('tenant', 'created_by')
    ordering = ('-created_at',)
    date_hierarchy = 'created_at'
    inlines = [SLADefinitionInline]
    
    fieldsets = (
        (None, {
            'fields': ('id', 'name', 'slug', 'description')
        }),
        (_('BPMN Content'), {
            'fields': ('bpmn_xml',),
            'classes': ('collapse',)
        }),
        (_('Versioning'), {
            'fields': ('version', 'is_deployed', 'deployed_at', 'is_active')
        }),
        (_('Metadata'), {
            'fields': ('metadata', 'tenant', 'created_by')
        }),
        (_('Timestamps'), {
            'fields': ('created_at', 'updated_at'),
            'classes': ('collapse',)
        }),
    )

    def get_queryset(self, request):
        return super().get_queryset(request).select_related('tenant', 'created_by')


@admin.register(ProcessInstance)
class ProcessInstanceAdmin(admin.ModelAdmin):
    """Admin for ProcessInstance model."""
    list_display = (
        'id',
        'definition',
        'business_key',
        'status_badge',
        'started_by',
        'tenant',
        'started_at',
        'completed_at',
    )
    list_filter = (
        'status',
        'tenant',
        'started_at',
        'completed_at',
    )
    search_fields = (
        'id',
        'business_key',
        'definition__name',
    )
    readonly_fields = (
        'id',
        'started_at',
        'completed_at',
        'cancelled_at',
    )
    autocomplete_fields = ('tenant', 'definition', 'started_by')
    ordering = ('-started_at',)
    date_hierarchy = 'started_at'
    inlines = [TaskInline, ProcessVariableInline, ProcessHistoryInline]

    fieldsets = (
        (None, {
            'fields': ('id', 'definition', 'business_key', 'status')
        }),
        (_('Context'), {
            'fields': ('context', 'current_element_ids'),
            'classes': ('collapse',)
        }),
        (_('User'), {
            'fields': ('tenant', 'started_by')
        }),
        (_('Timestamps'), {
            'fields': ('started_at', 'completed_at', 'cancelled_at')
        }),
        (_('Error'), {
            'fields': ('error_message',),
            'classes': ('collapse',)
        }),
    )

    def status_badge(self, obj):
        colors = {
            'running': 'blue',
            'completed': 'green',
            'cancelled': 'orange',
            'failed': 'red',
            'suspended': 'gray',
        }
        color = colors.get(obj.status, 'gray')
        return format_html(
            '<span style="padding: 3px 8px; border-radius: 3px; background-color: {}; color: white;">{}</span>',
            color,
            obj.get_status_display()
        )
    status_badge.short_description = _('وضعیت')
    status_badge.admin_order_field = 'status'

    def get_queryset(self, request):
        return super().get_queryset(request).select_related(
            'tenant', 'definition', 'started_by'
        )


@admin.register(Task)
class TaskAdmin(admin.ModelAdmin):
    """Admin for Task model."""
    list_display = (
        'name',
        'task_type',
        'status_badge',
        'assignee',
        'priority',
        'due_date',
        'instance',
        'tenant',
        'created_at',
    )
    list_filter = (
        'status',
        'task_type',
        'tenant',
        'created_at',
        'due_date',
    )
    search_fields = (
        'name',
        'description',
        'task_definition_key',
        'instance__business_key',
    )
    readonly_fields = (
        'id',
        'created_at',
        'claimed_at',
        'completed_at',
    )
    autocomplete_fields = ('tenant', 'instance', 'assignee')
    ordering = ('-priority', '-created_at')
    date_hierarchy = 'created_at'
    inlines = [TaskAssignmentInline]

    fieldsets = (
        (None, {
            'fields': ('id', 'instance', 'name', 'description')
        }),
        (_('Task Definition'), {
            'fields': ('task_definition_key', 'element_id', 'task_type')
        }),
        (_('Form & Variables'), {
            'fields': ('form_data', 'input_variables', 'output_variables'),
            'classes': ('collapse',)
        }),
        (_('Assignment'), {
            'fields': ('assignee', 'status', 'priority')
        }),
        (_('Timing'), {
            'fields': ('due_date', 'created_at', 'claimed_at', 'completed_at')
        }),
        (_('Error'), {
            'fields': ('error_message',),
            'classes': ('collapse',)
        }),
        (_('Tenant'), {
            'fields': ('tenant',)
        }),
    )

    def status_badge(self, obj):
        colors = {
            'created': 'blue',
            'assigned': 'cyan',
            'claimed': 'purple',
            'completed': 'green',
            'cancelled': 'orange',
            'failed': 'red',
        }
        color = colors.get(obj.status, 'gray')
        return format_html(
            '<span style="padding: 3px 8px; border-radius: 3px; background-color: {}; color: white;">{}</span>',
            color,
            obj.get_status_display()
        )
    status_badge.short_description = _('وضعیت')
    status_badge.admin_order_field = 'status'

    def get_queryset(self, request):
        return super().get_queryset(request).select_related(
            'tenant', 'instance', 'instance__definition', 'assignee'
        )


@admin.register(TaskAssignment)
class TaskAssignmentAdmin(admin.ModelAdmin):
    """Admin for TaskAssignment model."""
    list_display = (
        'task',
        'user',
        'group',
        'assignment_type',
        'is_active',
        'assigned_at',
    )
    list_filter = (
        'assignment_type',
        'is_active',
        'assigned_at',
    )
    search_fields = (
        'task__name',
        'user__email',
        'group__name',
    )
    readonly_fields = (
        'id',
        'assigned_at',
        'unassigned_at',
    )
    autocomplete_fields = ('task', 'user', 'group')
    ordering = ('-assigned_at',)

    def get_queryset(self, request):
        return super().get_queryset(request).select_related(
            'task', 'user', 'group'
        )


@admin.register(ProcessVariable)
class ProcessVariableAdmin(admin.ModelAdmin):
    """Admin for ProcessVariable model."""
    list_display = (
        'name',
        'type',
        'value_preview',
        'scope',
        'instance',
        'updated_at',
    )
    list_filter = (
        'type',
        'created_at',
    )
    search_fields = (
        'name',
        'instance__business_key',
    )
    readonly_fields = (
        'id',
        'created_at',
        'updated_at',
    )
    autocomplete_fields = ('instance',)
    ordering = ('-updated_at',)

    def value_preview(self, obj):
        value_str = str(obj.value)
        if len(value_str) > 50:
            return value_str[:50] + '...'
        return value_str
    value_preview.short_description = _('مقدار')

    def get_queryset(self, request):
        return super().get_queryset(request).select_related('instance')


@admin.register(ProcessHistory)
class ProcessHistoryAdmin(admin.ModelAdmin):
    """Admin for ProcessHistory model."""
    list_display = (
        'event_type',
        'instance',
        'task',
        'user',
        'element_id',
        'created_at',
    )
    list_filter = (
        'event_type',
        'created_at',
    )
    search_fields = (
        'instance__business_key',
        'comment',
    )
    readonly_fields = (
        'id',
        'instance',
        'task',
        'user',
        'event_type',
        'element_id',
        'old_value',
        'new_value',
        'comment',
        'created_at',
    )
    ordering = ('-created_at',)
    date_hierarchy = 'created_at'

    def has_add_permission(self, request):
        return False

    def has_change_permission(self, request, obj=None):
        return False

    def has_delete_permission(self, request, obj=None):
        return False

    def get_queryset(self, request):
        return super().get_queryset(request).select_related(
            'instance', 'task', 'user'
        )


@admin.register(SLADefinition)
class SLADefinitionAdmin(admin.ModelAdmin):
    """Admin for SLADefinition model."""
    list_display = (
        'task_definition_key',
        'definition',
        'duration_display',
        'action_on_violation',
        'is_active',
    )
    list_filter = (
        'action_on_violation',
        'duration_unit',
        'is_active',
    )
    search_fields = (
        'task_definition_key',
        'definition__name',
    )
    readonly_fields = ('id',)
    autocomplete_fields = ('definition',)

    def duration_display(self, obj):
        return f"{obj.duration_value} {obj.get_duration_unit_display()}"
    duration_display.short_description = _('مدت زمان')

    def get_queryset(self, request):
        return super().get_queryset(request).select_related('definition')


@admin.register(SLAViolation)
class SLAViolationAdmin(admin.ModelAdmin):
    """Admin for SLAViolation model."""
    list_display = (
        'task',
        'sla_definition',
        'expected_completion',
        'violation_time',
        'is_resolved',
        'resolved_at',
    )
    list_filter = (
        'is_resolved',
        'violation_time',
    )
    search_fields = (
        'task__name',
    )
    readonly_fields = (
        'id',
        'violation_time',
    )
    autocomplete_fields = ('task', 'sla_definition')
    ordering = ('-violation_time',)

    def get_queryset(self, request):
        return super().get_queryset(request).select_related(
            'task', 'sla_definition'
        )