from datetime import timedelta

from django.contrib.auth import get_user_model
from django.core.paginator import Paginator
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.db import transaction
from django.db.models import Count, Q, Sum
from django.shortcuts import get_object_or_404, redirect, render
from django.utils import timezone
from django.views.decorators.http import require_POST

from pricing.views import supervisor_required
from crm.dashboard import farmers_of, tasks_of, transfer_work
from .forms import ROLE_LABELS, TeamMemberForm, TransferWorkForm, manageable_users
from .models import LoginEvent, TrustedDevice
from .utils import log_event, send_invite

SUMMARY_DAYS = 30
# Скільки різних IP чи браузерів за місяць уже схоже на спільний доступ
SUSPICIOUS_DEVICES = 3
SUSPICIOUS_DISPLACED = 3


@supervisor_required
def login_log(request):
    since = timezone.now() - timedelta(days=SUMMARY_DAYS)
    recent = Q(login_events__created_at__gte=since)
    # Через pk__in, а не join по групах: інакше людина з двома ролями рахувалася б двічі
    members = get_user_model().objects.filter(groups__name__in=['Managers', 'Logists'])
    users = (get_user_model().objects.filter(pk__in=members.values('pk'), is_active=True)
             .annotate(logins=Count('login_events', filter=recent & Q(login_events__kind='login')),
                       ips=Count('login_events__ip', filter=recent & Q(login_events__kind='login'), distinct=True),
                       browsers=Count('login_events__user_agent', filter=recent & Q(login_events__kind='login'),
                                      distinct=True),
                       displaced=Count('login_events', filter=recent & Q(login_events__kind='displaced')),
                       exported=Sum('login_events__rows', filter=recent & Q(login_events__kind='export')))
             .order_by('-displaced', '-ips', 'first_name', 'last_name'))
    failed = dict(LoginEvent.objects.filter(kind='failed', created_at__gte=since)
                  .values_list('email').annotate(n=Count('id')))
    summary = []
    for user in users:
        user.failed = failed.get(user.email, 0)
        user.suspicious = (user.ips >= SUSPICIOUS_DEVICES or user.browsers >= SUSPICIOUS_DEVICES
                           or user.displaced >= SUSPICIOUS_DISPLACED)
        summary.append(user)

    events = LoginEvent.objects.select_related('user')
    selected_user, selected_kind = request.GET.get('user', ''), request.GET.get('kind', '')
    if selected_user.isdigit():
        events = events.filter(user_id=selected_user)
    if selected_kind in dict(LoginEvent.KIND_CHOICES):
        events = events.filter(kind=selected_kind)
    page = Paginator(events, 50).get_page(request.GET.get('page'))

    params = request.GET.copy()
    params.pop('page', None)
    context = {
        'summary': summary,
        'summary_days': SUMMARY_DAYS,
        'events': page,
        'kinds': LoginEvent.KIND_CHOICES,
        'selected_user': selected_user,
        'selected_kind': selected_kind,
        'query_params': params.urlencode(),
    }
    return render(request, 'security/login_log.html', context)


@supervisor_required
def devices(request):
    all_devices = TrustedDevice.objects.select_related('user', 'decided_by').order_by('user__first_name', 'user__email', '-last_seen_at')
    context = {
        'pending': [d for d in all_devices if d.status == TrustedDevice.PENDING],
        'approved': [d for d in all_devices if d.status == TrustedDevice.APPROVED],
        'rejected': [d for d in all_devices if d.status == TrustedDevice.REJECTED],
    }
    return render(request, 'security/devices.html', context)


@supervisor_required
@require_POST
def device_decide(request, device_id):
    device = get_object_or_404(TrustedDevice, id=device_id)
    status = {'approve': TrustedDevice.APPROVED, 'reject': TrustedDevice.REJECTED}.get(request.POST.get('action'))
    if status:
        device.status = status
        device.decided_by = request.user
        device.decided_at = timezone.now()
        device.save(update_fields=['status', 'decided_by', 'decided_at'])
        name = device.user.get_full_name() or device.user.email
        messages.success(request, f'{name}: пристрій {"схвалено" if status == TrustedDevice.APPROVED else "заблоковано"}.')
    return redirect('security:devices')


@login_required
def device_pending(request):
    device = getattr(request, 'security_device', None)
    if device is None or device.status == TrustedDevice.APPROVED:
        return redirect('home')
    return render(request, 'security/device_pending.html', {'device': device})


def display_name(user):
    return user.get_full_name() or user.email


def role_names(user):
    return [label for name, label in ROLE_LABELS if name in {g.name for g in user.groups.all()}]


def report_invite(request, user):
    if send_invite(request, user):
        messages.success(request, f'Посилання для встановлення пароля надіслано на {user.email}.')
    else:
        messages.error(request, f'Не вдалося надіслати лист на {user.email}. Спробуйте ще раз кнопкою «Надіслати посилання».')


@supervisor_required
def team_list(request):
    users = list(manageable_users().prefetch_related('groups').order_by('first_name', 'last_name', 'email'))
    for user in users:
        user.role_names = role_names(user)
        user.open_tasks = tasks_of(user).count()
        user.farmers_count = farmers_of(user).count()
    return render(request, 'security/team_list.html', {
        'active_users': [u for u in users if u.is_active],
        'removed_users': [u for u in users if not u.is_active],
    })


@supervisor_required
def team_member_edit(request, user_id=None):
    member = get_object_or_404(manageable_users(), id=user_id) if user_id else None
    if request.method == 'POST':
        form = TeamMemberForm(request.POST, instance=member)
        if form.is_valid():
            old_roles = form.initial.get('roles', [])
            changed = form.has_changed()
            saved = form.save()
            new_roles = form.cleaned_data['roles']
            labels = dict(ROLE_LABELS)
            roles_text = ', '.join(labels[r] for r in new_roles)
            if member is None:
                log_event(request, 'user_created', user=request.user, email=request.user.email,
                          detail=f'{saved.email}: {roles_text}')
                messages.success(request, f'Користувача {display_name(saved)} додано.')
                report_invite(request, saved)
            elif changed:
                detail = saved.email
                if set(old_roles) != set(new_roles):
                    old_text = ', '.join(labels[r] for r in old_roles) or 'без ролі'
                    detail += f': {old_text} → {roles_text}'
                log_event(request, 'user_changed', user=request.user, email=request.user.email, detail=detail)
                messages.success(request, f'Дані користувача {display_name(saved)} збережено.')
            return redirect('security:team_list')
    else:
        form = TeamMemberForm(instance=member)
    return render(request, 'security/team_form.html', {'form': form, 'member': member})


@supervisor_required
def team_member_remove(request, user_id):
    """Видалення лише закриває доступ: справжнє видалення стерло б історію взаємодій людини.

    Задачі й фермерів не можна покинути: поки вони є, без одержувача нічого не відбудеться.
    Цю ж сторінку використовуємо, щоб передати роботу вже видаленої людини.
    """
    member = get_object_or_404(manageable_users(), id=user_id)
    tasks, farmers = tasks_of(member).count(), farmers_of(member).count()
    has_work = tasks or farmers
    data = request.POST if request.method == 'POST' else None
    form = TransferWorkForm(data, member=member) if has_work else None
    if request.method == 'POST' and (form is None or form.is_valid()):
        with transaction.atomic():
            if form:
                recipient = form.cleaned_data['recipient']
                tasks, farmers = transfer_work(member, recipient)
                log_event(request, 'work_transferred', user=request.user, email=request.user.email,
                          detail=f'{member.email} → {recipient.email}: задач {tasks}, фермерів {farmers}')
            was_active = member.is_active
            if was_active:
                member.is_active = False
                member.save(update_fields=['is_active'])
                log_event(request, 'user_removed', user=request.user, email=request.user.email, detail=member.email)
        if was_active:
            messages.success(request, f'Користувача {display_name(member)} видалено: доступ закрито, історію збережено.')
        if form:
            messages.success(request, f'{display_name(recipient)} отримує задач: {tasks}, фермерів: {farmers}.')
        return redirect('security:team_list')
    return render(request, 'security/team_remove.html', {'member': member, 'form': form, 'tasks': tasks, 'farmers': farmers})


@supervisor_required
@require_POST
def team_member_restore(request, user_id):
    member = get_object_or_404(manageable_users(), id=user_id, is_active=False)
    member.is_active = True
    member.save(update_fields=['is_active'])
    log_event(request, 'user_restored', user=request.user, email=request.user.email, detail=member.email)
    messages.success(request, f'Користувача {display_name(member)} відновлено.')
    return redirect('security:team_list')


@supervisor_required
@require_POST
def team_member_invite(request, user_id):
    member = get_object_or_404(manageable_users(), id=user_id, is_active=True)
    report_invite(request, member)
    return redirect('security:team_list')
