from django.urls import reverse
from django.conf import settings
from django.db.models import Q, F
from django.utils import timezone

from djadhere.utils import send_notification
from services.models import IPResource

import re
from ipaddress import IPv4Address, AddressValueError


def notify_allocation(request, new_alloc, old_alloc=None):
    fields = ['resource', 'service', 'route', 'start', 'end', 'notes']

    benevole = '%s <%s>' % (request.user.username, request.user.email)
    message = 'Bénévole : ' + benevole
    message += '\n\nAllocation :'

    diff = False
    for field in fields:
        new_attr = getattr(new_alloc, field)
        if new_attr == '' or new_attr is None:
            new_attr = '-'
        if old_alloc:
            old_attr = getattr(old_alloc, field)
            if old_attr == '' or old_attr is None:
                old_attr = '-'
        if old_alloc and old_attr != new_attr:
            message += '\n-%12s: %s\n+%12s: %s' % (field, old_attr, field, new_attr)
            diff = True
        else:
            message += '\n %12s: %s' % (field, new_attr)

    url = 'https' if request.is_secure() else 'http'
    url += '://' + request.get_host()
    url += reverse('admin:services_ipresource_change', args=(new_alloc.resource.pk,))
    message += '\n\nVoir : ' + url

    if old_alloc and diff:
        sujet = 'Modification d’une allocation'
    elif not old_alloc:
        sujet = 'Nouvelle allocation'
    else:
        sujet = None

    if sujet:
        sujet += ' ADT%d' % new_alloc.service.adhesion.pk
        send_notification(sujet, message, settings.ALLOCATIONS_EMAILS, cc=[benevole])


def fastping_update(f):
    regex = re.compile('^(?P<ip>[0-9.]+)[ ]+: (?P<p1>([0-9]+.[0-9]+|-)) (?P<p2>([0-9]+.[0-9]+|-))'
                       ' (?P<p3>([0-9]+.[0-9]+|-)) (?P<p4>([0-9]+.[0-9]+|-)) (?P<p5>([0-9]+.[0-9]+|-))$')
    up_count = IPResource.objects.filter(last_check__isnull=False).filter(last_time_up=F('last_check')).count()
    down_count = IPResource.objects.filter(last_check__isnull=False).exclude(last_time_up=F('last_check')).count()
    unknown_count = IPResource.objects.filter(last_check__isnull=True).count()

    up, down, unknown = set(), set(), set()
    for line in f:
        try:
            line = line.decode('utf-8')
        except UnicodeDecodeError:
            continue
        g = regex.match(line)
        if not g:
            continue
        try:
            ip = IPv4Address(g.group('ip'))
        except AddressValueError:
            continue
        p = [ g.group('p%d' % i) for i in [1, 2, 3, 4, 5] ]
        if all(map(lambda p: p == '-', p)):
            down.add(ip.compressed)
        else:
            up.add(ip.compressed)

    up = up - down # suppression des doublons

    up = IPResource.objects.filter(ip__in=up)
    down = IPResource.objects.filter(ip__in=down)
    unknown = IPResource.objects.exclude(Q(pk__in=up) | Q(pk__in=down))

    up.exclude(last_time_up=F('last_check')).count()
    down.filter(last_time_up=F('last_check')).count()

    now = timezone.now()

    up.update(last_time_up=now, last_check=now)
    down.update(last_check=now)

    upped = len(up) - up_count
    downed = len(down) - down_count
    unknowned = len(unknown) - unknown_count

    return "UP: %d (%+d), DOWN: %d (%+d), UNKNOWN: %d (%+d)" \
            % (len(up), upped, len(down), downed, len(unknown), unknowned)