"""Roles and panel Users (UserRole.USER) CRUD for the web admin panel."""

from __future__ import annotations

from collections import OrderedDict

from django.contrib import messages
from django.contrib.auth import get_user_model
from django.db import transaction
from django.db.models import Count, Q
from django.http import FileResponse, HttpResponseForbidden, JsonResponse
from django.shortcuts import get_object_or_404, redirect, render
from django.utils.dateparse import parse_date
from django.views.decorators.http import require_http_methods, require_POST

from accounts.audit import log_audit
from accounts.decorators import admin_required
from accounts.mail import send_contact_query_reply
from accounts.models import (
    AuditLog,
    ContactQuery,
    RbacPermission,
    RbacRole,
    RbacRolePermission,
    UserAgreementAcceptance,
    UserRbacRole,
    UserRole,
)
from accounts.rbac import (
    can_manage_rbac_roles,
    can_mutate_panel_users,
    can_view_panel_users,
    permission_required,
)
from accounts.rbac_catalog import RBAC_PERMISSION_CATALOG
from core.datatables import is_datatables_request, paginate_datatables_queryset

User = get_user_model()


def _is_ajax(request):
    return request.headers.get('X-Requested-With') == 'XMLHttpRequest'


def _json_error(message, errors=None, status=400):
    payload = {'success': False, 'message': message, 'error': message}
    if errors is not None:
        payload['errors'] = errors
    return JsonResponse(payload, status=status)


def _forbidden(request, message='Permission denied.'):
    if _is_ajax(request):
        return JsonResponse({'success': False, 'message': message, 'error': message}, status=403)
    return HttpResponseForbidden(message)


# Single-permission modules shown 3-up on the role form.
_ROLE_FORM_COMPACT_ROWS = (
    ('dashboard', 'shippers', 'transporters'),
    ('drivers', 'loads', 'settings'),
    ('audit_logs', 'queries', 'user_agreements'),
)


def _permissions_grouped():
    """Preserve catalog module order; attach DB permission rows."""
    by_module = OrderedDict()
    for module, module_label, actions in RBAC_PERMISSION_CATALOG:
        by_module[module] = {
            'module': module,
            'label': module_label,
            'permissions': [],
        }
    for perm in RbacPermission.objects.order_by('sort_order', 'module', 'action'):
        bucket = by_module.get(perm.module)
        if bucket is None:
            by_module[perm.module] = {
                'module': perm.module,
                'label': perm.module_label or perm.module,
                'permissions': [perm],
            }
        else:
            bucket['permissions'].append(perm)
    return list(by_module.values())


def _role_form_permission_layout():
    """Split modules into compact 3-column rows and remaining full-width groups."""
    groups = _permissions_grouped()
    by_module = {g['module']: g for g in groups}
    compact_slugs = {slug for row in _ROLE_FORM_COMPACT_ROWS for slug in row}
    compact_rows = []
    for row in _ROLE_FORM_COMPACT_ROWS:
        compact_rows.append([by_module[slug] for slug in row if slug in by_module])
    other_groups = [g for g in groups if g['module'] not in compact_slugs]
    return compact_rows, other_groups


def _role_form_context(**extra):
    compact_rows, other_groups = _role_form_permission_layout()
    ctx = {
        'compact_rows': compact_rows,
        'other_groups': other_groups,
    }
    ctx.update(extra)
    return ctx


def _role_row_data(role):
    return {
        'id': role.id,
        'name': role.name,
        'is_active': role.is_active,
        'permission_count': getattr(role, 'permission_count', role.permissions.count()),
        'user_count': getattr(role, 'user_count', role.assigned_users.count()),
        'edit_url': f'/roles/{role.id}/edit',
        'delete_url': f'/roles/{role.id}/delete',
    }


def _panel_user_row_data(user):
    role_name = ''
    assignment = getattr(user, 'rbac_assignment', None)
    if assignment and assignment.role_id:
        role_name = assignment.role.name
    return {
        'id': user.id,
        'name': (f'{user.first_name} {user.last_name}'.strip() or user.username),
        'email': user.email or user.username,
        'phone': getattr(getattr(user, 'role', None), 'phone', '') or '',
        'role_name': role_name,
        'is_active': user.is_active,
        'edit_url': f'/panel-users/{user.id}/edit',
        'delete_url': f'/panel-users/{user.id}/delete',
        'detail_url': f'/panel-users/{user.id}',
    }


def _panel_users_qs():
    return (
        User.objects.filter(is_staff=True, is_superuser=False, role__role=UserRole.Role.USER)
        .select_related('role', 'rbac_assignment', 'rbac_assignment__role')
        .order_by('-id')
    )


# ---------------------------------------------------------------------------
# Roles
# ---------------------------------------------------------------------------

@admin_required
@require_http_methods(['GET'])
def admin_roles(request):
    if not can_manage_rbac_roles(request.user):
        return _forbidden(request)
    base_qs = RbacRole.objects.annotate(
        permission_count=Count('permissions', distinct=True),
        user_count=Count('assigned_users', distinct=True),
    )
    if is_datatables_request(request):
        return paginate_datatables_queryset(
            request,
            base_qs,
            _role_row_data,
            search_fields=['name'],
            order_fields=['name', 'is_active', 'permission_count', 'user_count', None],
            default_order=['name'],
        )
    roles = base_qs.order_by('name')
    return render(request, 'core/admin/role_list.html', {'roles': roles})


@admin_required
@require_http_methods(['GET', 'POST'])
def admin_role_create(request):
    if not can_manage_rbac_roles(request.user):
        return _forbidden(request)
    if request.method == 'POST':
        name = (request.POST.get('name') or '').strip()
        is_active = request.POST.get('is_active') == 'on'
        perm_ids = [int(x) for x in request.POST.getlist('permissions') if str(x).isdigit()]
        if not name:
            messages.error(request, 'Role name is required.')
            return render(request, 'core/admin/role_form.html', _role_form_context(
                selected_perm_ids=set(perm_ids),
                role=None,
                form_name=name,
                form_is_active=is_active,
            ))
        if RbacRole.objects.filter(name__iexact=name).exists():
            messages.error(request, 'A role with this name already exists.')
            return render(request, 'core/admin/role_form.html', _role_form_context(
                selected_perm_ids=set(perm_ids),
                role=None,
                form_name=name,
                form_is_active=is_active,
            ))
        with transaction.atomic():
            role = RbacRole.objects.create(
                name=name,
                is_active=is_active,
            )
            perms = RbacPermission.objects.filter(id__in=perm_ids)
            RbacRolePermission.objects.bulk_create([
                RbacRolePermission(role=role, permission=p) for p in perms
            ])
        log_audit(
            request,
            action=AuditLog.Action.CREATE,
            module='roles',
            summary=f'Created role "{role.name}"',
            object_type='RbacRole',
            object_id=role.id,
            object_repr=role.name,
            metadata={'permission_ids': perm_ids},
        )
        messages.success(request, 'Role created successfully.')
        return redirect('core:roles')
    return render(request, 'core/admin/role_form.html', _role_form_context(
        selected_perm_ids=set(),
        role=None,
        form_name='',
        form_is_active=True,
    ))


@admin_required
@require_http_methods(['GET', 'POST'])
def admin_role_edit(request, pk):
    if not can_manage_rbac_roles(request.user):
        return _forbidden(request)
    role = get_object_or_404(RbacRole.objects.prefetch_related('permissions'), pk=pk)
    if request.method == 'POST':
        name = (request.POST.get('name') or '').strip()
        is_active = request.POST.get('is_active') == 'on'
        perm_ids = [int(x) for x in request.POST.getlist('permissions') if str(x).isdigit()]
        if not name:
            messages.error(request, 'Role name is required.')
            return render(request, 'core/admin/role_form.html', _role_form_context(
                selected_perm_ids=set(perm_ids),
                role=role,
                form_name=name,
                form_is_active=is_active,
            ))
        if RbacRole.objects.filter(name__iexact=name).exclude(pk=role.pk).exists():
            messages.error(request, 'A role with this name already exists.')
            return render(request, 'core/admin/role_form.html', _role_form_context(
                selected_perm_ids=set(perm_ids),
                role=role,
                form_name=name,
                form_is_active=is_active,
            ))
        with transaction.atomic():
            role.name = name
            role.is_active = is_active
            role.save(update_fields=['name', 'is_active', 'updated_at'])
            role.role_permissions.all().delete()
            perms = RbacPermission.objects.filter(id__in=perm_ids)
            RbacRolePermission.objects.bulk_create([
                RbacRolePermission(role=role, permission=p) for p in perms
            ])
        log_audit(
            request,
            action=AuditLog.Action.UPDATE,
            module='roles',
            summary=f'Updated role "{role.name}"',
            object_type='RbacRole',
            object_id=role.id,
            object_repr=role.name,
            metadata={'permission_ids': perm_ids, 'is_active': is_active},
        )
        messages.success(request, 'Role updated successfully.')
        return redirect('core:roles')
    selected = set(role.permissions.values_list('id', flat=True))
    return render(request, 'core/admin/role_form.html', _role_form_context(
        selected_perm_ids=selected,
        role=role,
        form_name=role.name,
        form_is_active=role.is_active,
    ))


@admin_required
@require_POST
def admin_role_delete(request, pk):
    if not can_manage_rbac_roles(request.user):
        return _forbidden(request)
    role = get_object_or_404(RbacRole, pk=pk)
    if role.assigned_users.exists():
        msg = 'Cannot delete a role that is assigned to users. Reassign them first.'
        if _is_ajax(request):
            return _json_error(msg)
        messages.error(request, msg)
        return redirect('core:roles')
    role_name = role.name
    role_id = role.id
    role.delete()
    log_audit(
        request,
        action=AuditLog.Action.DELETE,
        module='roles',
        summary=f'Deleted role "{role_name}"',
        object_type='RbacRole',
        object_id=role_id,
        object_repr=role_name,
    )
    if _is_ajax(request):
        return JsonResponse({'success': True, 'message': 'Role deleted successfully.'})
    messages.success(request, 'Role deleted successfully.')
    return redirect('core:roles')


# ---------------------------------------------------------------------------
# Panel Users (UserRole.USER)
# ---------------------------------------------------------------------------

@admin_required
@require_http_methods(['GET'])
def admin_panel_users(request):
    if not can_view_panel_users(request.user):
        return _forbidden(request)
    base_qs = _panel_users_qs()
    if is_datatables_request(request):
        return paginate_datatables_queryset(
            request,
            base_qs,
            _panel_user_row_data,
            search_fields=['email', 'username', 'first_name', 'last_name'],
            order_fields=['first_name', 'email', None, 'is_active', None],
            default_order=['-id'],
        )
    return render(request, 'core/admin/panel_user_list.html', {
        'can_mutate': can_mutate_panel_users(request.user),
        'roles': RbacRole.objects.filter(is_active=True).order_by('name'),
    })


@admin_required
@require_http_methods(['GET'])
def admin_panel_user_detail(request, user_id):
    if not can_view_panel_users(request.user):
        return _forbidden(request)
    target = get_object_or_404(_panel_users_qs(), pk=user_id)
    return render(request, 'core/admin/panel_user_detail.html', {
        'panel_user': target,
        'can_mutate': can_mutate_panel_users(request.user),
    })


@admin_required
@require_http_methods(['GET', 'POST'])
def admin_panel_user_create(request):
    if not can_mutate_panel_users(request.user):
        return _forbidden(request)
    roles = RbacRole.objects.filter(is_active=True).order_by('name')
    if request.method == 'POST':
        email = (request.POST.get('email') or '').strip().lower()
        password = request.POST.get('password') or ''
        first_name = (request.POST.get('first_name') or '').strip()
        last_name = (request.POST.get('last_name') or '').strip()
        phone = (request.POST.get('phone') or '').strip()
        role_id = request.POST.get('rbac_role') or ''
        is_active = request.POST.get('is_active') == 'on'
        errors = {}
        if not email:
            errors['email'] = ['Email is required.']
        if len(password) < 8:
            errors['password'] = ['Password must be at least 8 characters.']
        if not role_id.isdigit():
            errors['rbac_role'] = ['RBAC role is required.']
        role = None
        if role_id.isdigit():
            role = RbacRole.objects.filter(pk=int(role_id), is_active=True).first()
            if not role:
                errors['rbac_role'] = ['Selected role is invalid or inactive.']
        if email and User.objects.filter(username=email).exists():
            errors['email'] = ['A user with this email already exists.']
        if errors:
            if _is_ajax(request):
                return _json_error('Validation failed.', errors)
            first_err = next(iter(errors.values()))[0]
            messages.error(request, first_err)
            return render(request, 'core/admin/panel_user_form.html', {
                'roles': roles,
                'panel_user': None,
                'form': {
                    'email': email,
                    'first_name': first_name,
                    'last_name': last_name,
                    'phone': phone,
                    'rbac_role': role_id,
                    'is_active': is_active,
                },
            })
        with transaction.atomic():
            created = User.objects.create_user(
                username=email,
                email=email,
                password=password,
                first_name=first_name,
                last_name=last_name,
                is_staff=True,
                is_superuser=False,
                is_active=is_active,
            )
            UserRole.objects.create(
                user=created,
                role=UserRole.Role.USER,
                phone=phone,
                language='en',
            )
            UserRbacRole.objects.create(user=created, role=role)
        log_audit(
            request,
            action=AuditLog.Action.CREATE,
            module='panel_users',
            summary=f'Created panel user {email}',
            object_type='User',
            object_id=created.id,
            object_repr=email,
            metadata={'rbac_role': role.name if role else ''},
        )
        if _is_ajax(request):
            created = _panel_users_qs().get(pk=created.pk)
            return JsonResponse({
                'success': True,
                'message': 'User created successfully.',
                'user': _panel_user_row_data(created),
            })
        messages.success(request, 'User created successfully.')
        return redirect('core:panel_users')
    return render(request, 'core/admin/panel_user_form.html', {
        'roles': roles,
        'panel_user': None,
        'form': {'is_active': True},
    })


@admin_required
@require_http_methods(['GET', 'POST'])
def admin_panel_user_edit(request, user_id):
    if not can_view_panel_users(request.user):
        return _forbidden(request)
    target = get_object_or_404(_panel_users_qs(), pk=user_id)
    can_mutate = can_mutate_panel_users(request.user)
    if request.method == 'POST' and not can_mutate:
        return _forbidden(request)
    roles = RbacRole.objects.filter(is_active=True).order_by('name')
    if request.method == 'POST':
        email = (request.POST.get('email') or '').strip().lower()
        password = request.POST.get('password') or ''
        first_name = (request.POST.get('first_name') or '').strip()
        last_name = (request.POST.get('last_name') or '').strip()
        phone = (request.POST.get('phone') or '').strip()
        role_id = request.POST.get('rbac_role') or ''
        is_active = request.POST.get('is_active') == 'on'
        errors = {}
        if not email:
            errors['email'] = ['Email is required.']
        if not role_id.isdigit():
            errors['rbac_role'] = ['RBAC role is required.']
        role = None
        if role_id.isdigit():
            role = RbacRole.objects.filter(pk=int(role_id), is_active=True).first()
            if not role:
                errors['rbac_role'] = ['Selected role is invalid or inactive.']
        if email and User.objects.filter(username=email).exclude(pk=target.pk).exists():
            errors['email'] = ['A user with this email already exists.']
        if password and len(password) < 8:
            errors['password'] = ['Password must be at least 8 characters.']
        if target.id == request.user.id and not is_active:
            errors['is_active'] = ['You cannot deactivate your own account.']
        if errors:
            if _is_ajax(request):
                return _json_error('Validation failed.', errors)
            messages.error(request, 'Validation failed.')
            return render(request, 'core/admin/panel_user_form.html', {
                'roles': roles,
                'panel_user': target,
                'can_mutate': can_mutate,
                'form': {
                    'email': email,
                    'first_name': first_name,
                    'last_name': last_name,
                    'phone': phone,
                    'rbac_role': role_id,
                    'is_active': is_active,
                },
            })
        with transaction.atomic():
            target.first_name = first_name
            target.last_name = last_name
            target.email = email
            target.username = email
            target.is_active = is_active
            update_fields = ['first_name', 'last_name', 'email', 'username', 'is_active']
            if password:
                target.set_password(password)
                update_fields.append('password')
            target.save(update_fields=update_fields)
            ur = target.role
            ur.phone = phone
            ur.role = UserRole.Role.USER
            ur.save(update_fields=['phone', 'role', 'updated_at'])
            assignment, _ = UserRbacRole.objects.get_or_create(
                user=target,
                defaults={'role': role},
            )
            if assignment.role_id != role.id:
                assignment.role = role
                assignment.save(update_fields=['role', 'updated_at'])
        log_audit(
            request,
            action=AuditLog.Action.UPDATE,
            module='panel_users',
            summary=f'Updated panel user {email}',
            object_type='User',
            object_id=target.id,
            object_repr=email,
            metadata={
                'rbac_role': role.name if role else '',
                'is_active': is_active,
                'password_changed': bool(password),
            },
        )
        if _is_ajax(request):
            target = _panel_users_qs().get(pk=target.pk)
            return JsonResponse({
                'success': True,
                'message': 'User updated successfully.',
                'user': _panel_user_row_data(target),
            })
        messages.success(request, 'User updated successfully.')
        return redirect('core:panel_users')

    assignment = getattr(target, 'rbac_assignment', None)
    return render(request, 'core/admin/panel_user_form.html', {
        'roles': roles,
        'panel_user': target,
        'can_mutate': can_mutate,
        'form': {
            'email': target.email,
            'first_name': target.first_name,
            'last_name': target.last_name,
            'phone': getattr(target.role, 'phone', ''),
            'rbac_role': str(assignment.role_id) if assignment else '',
            'is_active': target.is_active,
        },
    })


@admin_required
@require_POST
def admin_panel_user_delete(request, user_id):
    if not can_mutate_panel_users(request.user):
        return _forbidden(request)
    target = get_object_or_404(_panel_users_qs(), pk=user_id)
    if target.id == request.user.id:
        if _is_ajax(request):
            return _json_error('You cannot delete your own account.')
        messages.error(request, 'You cannot delete your own account.')
        return redirect('core:panel_users')
    email = target.email or target.username
    target_id = target.id
    target.delete()
    log_audit(
        request,
        action=AuditLog.Action.DELETE,
        module='panel_users',
        summary=f'Deleted panel user {email}',
        object_type='User',
        object_id=target_id,
        object_repr=email,
    )
    if _is_ajax(request):
        return JsonResponse({'success': True, 'message': 'User deleted successfully.'})
    messages.success(request, 'User deleted successfully.')
    return redirect('core:panel_users')


# ---------------------------------------------------------------------------
# Audit Logs
# ---------------------------------------------------------------------------

def _audit_log_row_data(row):
    return {
        'id': row.id,
        'created_at': row.created_at.strftime('%Y-%m-%d %H:%M:%S') if row.created_at else '',
        'actor': row.actor_email or row.actor_username or '—',
        'actor_role': row.get_actor_role_display(),
        'action': row.action,
        'action_display': row.get_action_display(),
        'module': row.module,
        'summary': row.summary,
        'object_repr': row.object_repr or '—',
        'object_type': row.object_type or '',
        'object_id': row.object_id or '',
        'metadata': row.metadata or {},
        'ip_address': row.ip_address or '',
        'path': row.path or '',
    }


def _filtered_audit_logs(request):
    qs = AuditLog.objects.all()
    actor = (request.GET.get('actor') or '').strip()
    module = (request.GET.get('module') or '').strip()
    action = (request.GET.get('action') or '').strip()
    date_from = parse_date((request.GET.get('date_from') or '').strip())
    date_to = parse_date((request.GET.get('date_to') or '').strip())
    if actor:
        qs = qs.filter(
            Q(actor_email__icontains=actor) | Q(actor_username__icontains=actor)
        )
    if module:
        qs = qs.filter(module=module)
    if action:
        qs = qs.filter(action=action)
    if date_from:
        qs = qs.filter(created_at__date__gte=date_from)
    if date_to:
        qs = qs.filter(created_at__date__lte=date_to)
    return qs


@admin_required
@permission_required('audit_logs.view')
@require_http_methods(['GET'])
def admin_audit_logs(request):
    base_qs = _filtered_audit_logs(request)
    if is_datatables_request(request):
        return paginate_datatables_queryset(
            request,
            base_qs,
            _audit_log_row_data,
            search_fields=['actor_email', 'actor_username', 'summary', 'object_repr', 'module'],
            order_fields=['created_at', 'actor_email', 'actor_role', 'action', 'module', 'summary', None],
            default_order=['-created_at'],
        )
    modules = (
        AuditLog.objects.order_by('module').values_list('module', flat=True).distinct()
    )
    return render(request, 'core/admin/audit_log_list.html', {
        'action_choices': AuditLog.Action.choices,
        'modules': list(modules),
        'filters': {
            'actor': request.GET.get('actor') or '',
            'module': request.GET.get('module') or '',
            'action': request.GET.get('action') or '',
            'date_from': request.GET.get('date_from') or '',
            'date_to': request.GET.get('date_to') or '',
        },
    })


# ---------------------------------------------------------------------------
# Contact Queries
# ---------------------------------------------------------------------------

def _contact_query_row_data(row):
    from django.urls import reverse

    return {
        'id': row.id,
        'created_at': row.created_at.strftime('%Y-%m-%d %H:%M') if row.created_at else '',
        'name': row.name,
        'email': row.email,
        'phone': row.phone,
        'status': row.status,
        'status_display': row.get_status_display(),
        'detail_url': reverse('core:query_detail', args=[row.id]),
        'message_preview': (row.message[:80] + '…') if len(row.message) > 80 else row.message,
    }


def _filtered_contact_queries(request):
    qs = ContactQuery.objects.all()
    email = (request.GET.get('email') or '').strip()
    status = (request.GET.get('status') or '').strip()
    date_from = parse_date((request.GET.get('date_from') or '').strip())
    date_to = parse_date((request.GET.get('date_to') or '').strip())
    if email:
        qs = qs.filter(Q(email__icontains=email) | Q(name__icontains=email))
    if status:
        qs = qs.filter(status=status)
    if date_from:
        qs = qs.filter(created_at__date__gte=date_from)
    if date_to:
        qs = qs.filter(created_at__date__lte=date_to)
    return qs


@admin_required
@permission_required('queries.view')
@require_http_methods(['GET'])
def admin_queries(request):
    base_qs = _filtered_contact_queries(request)
    if is_datatables_request(request):
        return paginate_datatables_queryset(
            request,
            base_qs,
            _contact_query_row_data,
            search_fields=['name', 'email', 'phone', 'message'],
            order_fields=['created_at', 'name', 'email', 'phone', 'status', None],
            default_order=['-created_at'],
        )
    return render(request, 'core/admin/query_list.html', {
        'status_choices': ContactQuery.Status.choices,
        'filters': {
            'email': request.GET.get('email') or '',
            'status': request.GET.get('status') or '',
            'date_from': request.GET.get('date_from') or '',
            'date_to': request.GET.get('date_to') or '',
        },
    })


@admin_required
@permission_required('queries.view')
@require_http_methods(['GET'])
def admin_query_detail(request, pk):
    from accounts.rbac import user_has_perm

    query = get_object_or_404(ContactQuery, pk=pk)
    return render(request, 'core/admin/query_detail.html', {
        'query': query,
        'can_update': user_has_perm(request.user, 'queries.update'),
    })


@admin_required
@permission_required('queries.update')
@require_POST
def admin_query_mark_viewed(request, pk):
    from django.utils import timezone

    query = get_object_or_404(ContactQuery, pk=pk)
    if query.status != ContactQuery.Status.REPLIED:
        query.status = ContactQuery.Status.VIEWED
        query.viewed_at = timezone.now()
        query.viewed_by = request.user
        query.save(update_fields=['status', 'viewed_at', 'viewed_by'])
        messages.success(request, 'Query marked as viewed.')
    else:
        messages.info(request, 'This query was already replied to.')
    return redirect('core:query_detail', pk=query.id)


@admin_required
@permission_required('queries.update')
@require_POST
def admin_query_reply(request, pk):
    from django.utils import timezone

    query = get_object_or_404(ContactQuery, pk=pk)
    subject = (request.POST.get('reply_subject') or '').strip()
    body = (request.POST.get('reply_body') or '').strip()
    if not subject or not body:
        messages.error(request, 'Reply subject and body are required.')
        return redirect('core:query_detail', pk=query.id)
    if len(subject) > 255:
        messages.error(request, 'Subject is too long (max 255 characters).')
        return redirect('core:query_detail', pk=query.id)

    try:
        send_contact_query_reply(to_email=query.email, subject=subject, body=body)
    except Exception:
        messages.error(request, 'Failed to send email. The query was not marked as replied.')
        return redirect('core:query_detail', pk=query.id)

    query.reply_subject = subject
    query.reply_body = body
    query.replied_at = timezone.now()
    query.replied_by = request.user
    query.status = ContactQuery.Status.REPLIED
    if not query.viewed_at:
        query.viewed_at = query.replied_at
        query.viewed_by = request.user
    query.save(update_fields=[
        'reply_subject', 'reply_body', 'replied_at', 'replied_by', 'status',
        'viewed_at', 'viewed_by',
    ])
    messages.success(request, f'Reply sent to {query.email}.')
    return redirect('core:query_detail', pk=query.id)


# ---------------------------------------------------------------------------
# User Agreement submissions
# ---------------------------------------------------------------------------

_UA_ACCOUNT_TYPE_CHOICES = (
    ('SHIPPER', 'Shipper'),
    ('TRANSPORTER', 'Transporter (fleet owner)'),
    ('DRIVER', 'Individual driver'),
    ('TRANSPORTER_DRIVER', 'Fleet driver'),
)


def _user_agreement_row_data(row):
    from django.urls import reverse

    return {
        'id': row.id,
        'accepted_at': row.accepted_at.strftime('%Y-%m-%d %H:%M') if row.accepted_at else '',
        'full_name': row.full_name_at_accept or '',
        'email': row.email_at_accept or '',
        'phone': row.phone_at_accept or '',
        'account_type': row.account_type_at_accept or '',
        'pdf_url': reverse('core:user_agreement_pdf', args=[row.id]),
    }


def _filtered_user_agreements(request):
    qs = UserAgreementAcceptance.objects.select_related('user', 'agreement_document').all()
    account_type = (request.GET.get('account_type') or '').strip().upper()
    q = (request.GET.get('q') or '').strip()
    if account_type:
        qs = qs.filter(account_type_at_accept=account_type)
    if q:
        qs = qs.filter(
            Q(full_name_at_accept__icontains=q)
            | Q(email_at_accept__icontains=q)
            | Q(phone_at_accept__icontains=q)
            | Q(user__email__icontains=q)
        )
    return qs


@admin_required
@permission_required('user_agreements.view')
@require_http_methods(['GET'])
def admin_user_agreements(request):
    base_qs = _filtered_user_agreements(request)
    if is_datatables_request(request):
        return paginate_datatables_queryset(
            request,
            base_qs,
            _user_agreement_row_data,
            search_fields=[
                'full_name_at_accept',
                'email_at_accept',
                'phone_at_accept',
                'account_type_at_accept',
            ],
            order_fields=[
                'accepted_at',
                'full_name_at_accept',
                'email_at_accept',
                'phone_at_accept',
                'account_type_at_accept',
                None,
            ],
            default_order=['-accepted_at'],
        )
    return render(request, 'core/admin/user_agreement_list.html', {
        'account_type_choices': _UA_ACCOUNT_TYPE_CHOICES,
        'filters': {
            'q': request.GET.get('q') or '',
            'account_type': request.GET.get('account_type') or '',
        },
    })


def _acceptance_pdf_ready(acceptance):
    """True when pdf_file is set and the file exists on storage."""
    if not acceptance.pdf_file:
        return False
    try:
        return acceptance.pdf_file.storage.exists(acceptance.pdf_file.name)
    except Exception:
        return False


@admin_required
@permission_required('user_agreements.view')
@require_http_methods(['GET'])
def admin_user_agreement_pdf(request, pk):
    acceptance = get_object_or_404(
        UserAgreementAcceptance.objects.select_related('user', 'agreement_document'),
        pk=pk,
    )
    # Always rebuild so PDF content matches current template (e.g. no version line).
    from api.pdf_agreement import save_acceptance_pdf
    try:
        if acceptance.pdf_file:
            acceptance.pdf_file.delete(save=False)
            acceptance.pdf_file = None
            acceptance.save(update_fields=['pdf_file'])
        save_acceptance_pdf(acceptance)
        acceptance.refresh_from_db()
    except Exception:
        from django.contrib import messages as django_messages
        django_messages.error(request, 'Failed to generate PDF for this acceptance.')
        return redirect('core:user_agreements')
    if not _acceptance_pdf_ready(acceptance):
        from django.contrib import messages as django_messages
        django_messages.error(request, 'PDF is not available for this acceptance.')
        return redirect('core:user_agreements')

    log_audit(
        request,
        action=AuditLog.Action.EXPORT,
        module='user_agreements',
        summary=f'Downloaded user agreement PDF #{acceptance.id}',
        object_type='UserAgreementAcceptance',
        object_id=acceptance.id,
        object_repr=f'Acceptance #{acceptance.id} user={acceptance.user_id}',
    )
    return FileResponse(
        acceptance.pdf_file.open('rb'),
        as_attachment=True,
        filename=f'user_agreement_{acceptance.user_id}.pdf',
        content_type='application/pdf',
    )
