"""
Views for support tickets and public Help Center / Contact Us.
"""
from django.contrib import messages
from django.contrib.auth.mixins import LoginRequiredMixin
from django.shortcuts import get_object_or_404, redirect, render
from django.views import View
from django.views.generic import ListView

from apps.support.forms import (
    ContactInquiryForm,
    SupportTicketCreateForm,
    TicketReplyForm,
    TicketStatusForm,
)
from apps.support.models import ContactInquiry, SupportTicket, TicketMessage
from utils.permissions import (
    AdminRequiredMixin,
    AdminOrSupportStaffMixin,
    can_manage_tickets,
    can_delete_tickets,
)


class HelpCenterView(View):
    """Public Help Center with FAQ and contact form."""
    template_name = 'support/help_center.html'

    def get(self, request):
        initial = {}
        if request.user.is_authenticated:
            initial = {
                'name': request.user.get_display_name(),
                'email': request.user.email or '',
            }
        return render(request, self.template_name, {
            'form': ContactInquiryForm(initial=initial),
            'submitted': False,
        })

    def post(self, request):
        form = ContactInquiryForm(request.POST)
        if form.is_valid():
            inquiry = form.save(commit=False)
            if request.user.is_authenticated:
                inquiry.user = request.user
            inquiry.save()
            messages.success(
                request,
                f'Thanks! Your message ({inquiry.reference}) was sent. We will reply soon.',
            )
            return redirect('support:help_center')
        return render(request, self.template_name, {
            'form': form,
            'submitted': False,
        })


class ContactInquiryListView(AdminOrSupportStaffMixin, ListView):
    template_name = 'support/contact_inquiry_list.html'
    context_object_name = 'inquiries'

    def get_queryset(self):
        qs = ContactInquiry.objects.select_related('user').all()
        status = self.request.GET.get('status', '')
        if status == 'open':
            qs = qs.filter(is_resolved=False)
        elif status == 'resolved':
            qs = qs.filter(is_resolved=True)
        topic = self.request.GET.get('topic', '')
        if topic:
            qs = qs.filter(topic=topic)
        return qs

    def get_context_data(self, **kwargs):
        ctx = super().get_context_data(**kwargs)
        base = ContactInquiry.objects.all()
        ctx['status_filter'] = self.request.GET.get('status', '')
        ctx['topic_filter'] = self.request.GET.get('topic', '')
        ctx['open_count'] = base.filter(is_resolved=False).count()
        ctx['resolved_count'] = base.filter(is_resolved=True).count()
        ctx['total_count'] = base.count()
        return ctx


class ContactInquiryDetailView(AdminOrSupportStaffMixin, View):
    template_name = 'support/contact_inquiry_detail.html'

    def get(self, request, pk):
        inquiry = get_object_or_404(ContactInquiry.objects.select_related('user'), pk=pk)
        return render(request, self.template_name, {'inquiry': inquiry})

    def post(self, request, pk):
        inquiry = get_object_or_404(ContactInquiry, pk=pk)
        action = request.POST.get('action', '')
        if action == 'resolve':
            inquiry.is_resolved = True
            inquiry.staff_notes = request.POST.get('staff_notes', inquiry.staff_notes).strip()
            inquiry.save(update_fields=['is_resolved', 'staff_notes', 'updated_at'])
            messages.success(request, f'{inquiry.reference} marked as resolved.')
        elif action == 'reopen':
            inquiry.is_resolved = False
            inquiry.save(update_fields=['is_resolved', 'updated_at'])
            messages.info(request, f'{inquiry.reference} reopened.')
        elif action == 'notes':
            inquiry.staff_notes = request.POST.get('staff_notes', '').strip()
            inquiry.save(update_fields=['staff_notes', 'updated_at'])
            messages.success(request, 'Notes saved.')
        elif action == 'delete' and request.user.role == 'admin':
            ref = inquiry.reference
            inquiry.delete()
            messages.success(request, f'{ref} deleted.')
            return redirect('support:contact_inquiries')
        return redirect('support:contact_inquiry_detail', pk=pk)


class MyTicketsView(LoginRequiredMixin, ListView):
    template_name = 'support/ticket_list.html'
    context_object_name = 'tickets'

    def get_queryset(self):
        user = self.request.user
        if can_manage_tickets(user):
            qs = SupportTicket.objects.select_related('created_by').all()
        else:
            qs = SupportTicket.objects.filter(created_by=user)
        status = self.request.GET.get('status', '')
        if status:
            qs = qs.filter(status=status)
        return qs.order_by('-updated_at')

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        user = self.request.user
        staff = can_manage_tickets(user)
        base = SupportTicket.objects.all() if staff else SupportTicket.objects.filter(created_by=user)
        context['status_filter'] = self.request.GET.get('status', '')
        context['is_staff_inbox'] = staff
        context['can_delete_tickets'] = can_delete_tickets(user)
        context['open_count'] = base.filter(status='open').count()
        context['progress_count'] = base.filter(status='in_progress').count()
        context['resolved_count'] = base.filter(status__in=['resolved', 'closed']).count()
        context['total_count'] = base.count()
        return context


class TicketCreateView(LoginRequiredMixin, View):
    template_name = 'support/ticket_create.html'

    def get(self, request):
        return render(request, self.template_name, {
            'form': SupportTicketCreateForm(),
        })

    def post(self, request):
        form = SupportTicketCreateForm(request.POST)
        if form.is_valid():
            ticket = form.save(commit=False)
            ticket.created_by = request.user
            ticket.save()
            TicketMessage.objects.create(
                ticket=ticket,
                author=request.user,
                body=form.cleaned_data['message'],
                is_staff_reply=False,
            )
            messages.success(request, f'Ticket {ticket.reference} submitted. We will get back to you soon.')
            return redirect('support:ticket_detail', pk=ticket.pk)
        return render(request, self.template_name, {'form': form})


class TicketDetailView(LoginRequiredMixin, View):
    template_name = 'support/ticket_detail.html'

    def _get_ticket(self, request, pk):
        ticket = get_object_or_404(SupportTicket.objects.select_related('created_by'), pk=pk)
        if not can_manage_tickets(request.user) and ticket.created_by_id != request.user.id:
            messages.error(request, 'You do not have access to this ticket.')
            return None
        return ticket

    def get(self, request, pk):
        ticket = self._get_ticket(request, pk)
        if ticket is None:
            return redirect('support:ticket_list')
        staff = can_manage_tickets(request.user)
        context = {
            'ticket': ticket,
            'messages_list': ticket.messages.select_related('author'),
            'reply_form': TicketReplyForm(),
            'status_form': TicketStatusForm(instance=ticket) if staff else None,
            'is_staff': staff,
            'can_delete': can_delete_tickets(request.user),
        }
        return render(request, self.template_name, context)

    def post(self, request, pk):
        ticket = self._get_ticket(request, pk)
        if ticket is None:
            return redirect('support:ticket_list')

        action = request.POST.get('action', 'reply')
        staff = can_manage_tickets(request.user)

        if action == 'delete':
            if not can_delete_tickets(request.user):
                messages.error(request, 'Only an admin can delete tickets.')
                return redirect('support:ticket_detail', pk=pk)
            ref = ticket.reference
            ticket.delete()
            messages.success(request, f'Ticket {ref} has been deleted.')
            return redirect('support:ticket_list')

        if action == 'status' and staff:
            status_form = TicketStatusForm(request.POST, instance=ticket)
            if status_form.is_valid():
                status_form.save()
                messages.success(request, 'Ticket status updated.')
            else:
                messages.error(request, 'Could not update status.')
            return redirect('support:ticket_detail', pk=pk)

        if ticket.status == 'closed' and not staff:
            messages.warning(request, 'This ticket is closed. Open a new ticket if you still need help.')
            return redirect('support:ticket_detail', pk=pk)

        reply_form = TicketReplyForm(request.POST)
        if reply_form.is_valid():
            msg = reply_form.save(commit=False)
            msg.ticket = ticket
            msg.author = request.user
            msg.is_staff_reply = staff
            msg.save()
            if staff and ticket.status == 'open':
                ticket.status = 'in_progress'
            ticket.save()
            messages.success(request, 'Reply posted.')
            return redirect('support:ticket_detail', pk=pk)

        context = {
            'ticket': ticket,
            'messages_list': ticket.messages.select_related('author'),
            'reply_form': reply_form,
            'status_form': TicketStatusForm(instance=ticket) if staff else None,
            'is_staff': staff,
            'can_delete': can_delete_tickets(request.user),
        }
        return render(request, self.template_name, context)


class TicketDeleteView(AdminRequiredMixin, View):
    """Admin-only permanent delete."""

    def post(self, request, pk):
        ticket = get_object_or_404(SupportTicket, pk=pk)
        ref = ticket.reference
        ticket.delete()
        messages.success(request, f'Ticket {ref} has been deleted.')
        return redirect('support:ticket_list')


class AdminTicketInboxView(AdminOrSupportStaffMixin, ListView):
    """Staff inbox — all tickets."""
    template_name = 'support/ticket_list.html'
    context_object_name = 'tickets'

    def get_queryset(self):
        qs = SupportTicket.objects.select_related('created_by').all()
        status = self.request.GET.get('status', '')
        if status:
            qs = qs.filter(status=status)
        return qs.order_by('-updated_at')

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        base = SupportTicket.objects.all()
        context['status_filter'] = self.request.GET.get('status', '')
        context['is_staff_inbox'] = True
        context['can_delete_tickets'] = can_delete_tickets(self.request.user)
        context['open_count'] = base.filter(status='open').count()
        context['progress_count'] = base.filter(status='in_progress').count()
        context['resolved_count'] = base.filter(status__in=['resolved', 'closed']).count()
        context['total_count'] = base.count()
        return context