import datetime
import re
from decimal import Decimal

import requests
from django import template
from django.utils.safestring import SafeText
from wcs.qommon import misc
from wcs.qommon.templatetags.qommon import unlazy

register = template.Library()


@register.filter
def clean_string(value):
    return value.replace(" ", "").replace(".", "").replace("-", "")


@register.filter
def check_class(value):
    return str(type(value))


@register.filter
def is_valid_belgian_nrn(value):
    return misc.validate_belgian_nrn(unlazy(value))


@register.filter
def is_strong_authentication(session_user):
    """
    Anciennement town.py is_strong_authentication
    session_user : session_user
    return : (bool) True si le user est connecté avec une authentification forte
    """
    return bool("_niss" in session_user.verified_fields)


@register.filter
def is_agent(session_user):
    """
    Anciennement town.py is_agent
    session_user : session_user
    return : (bool) True si le user est autorisé à aller dans le backoffice.
    """
    return session_user.can_go_in_backoffice()


@register.filter
def diff_dates(oldest_date, newest_date):
    """
    Anciennement town.py diff_dates
    oldest_date : datetime ou SafeText sous la forme "jj/mm/aaaa" ou "aaaa-mm-jj" ou "jj-mm-aaaa"
    newest_date : datetime ou SafeText sous la forme "jj/mm/aaaa" ou "aaaa-mm-jj" ou "jj-mm-aaaa"
    return : (str) nombre de jours de différence entre les 2 dates
    """

    def transform_date(fdate):
        if "/" in fdate:
            return datetime.datetime.strptime(fdate, "%d/%m/%Y")
        if "-" in fdate:
            if len(fdate.split("-")[0]) == 4:
                return datetime.datetime.strptime(fdate, "%Y-%m-%d")
            if len(fdate.split("-")[0]) == 2:
                return datetime.datetime.strptime(fdate, "%d-%m-%Y")

    if type(oldest_date) == SafeText:
        oldest_date = transform_date(oldest_date)
    if type(newest_date) == SafeText:
        newest_date = transform_date(newest_date)
    diff = abs((oldest_date - newest_date).days)
    return str(diff)


@register.filter
def get_birthday_from_nn(numero_national):
    """
    numero_national : (str) numero national peut contenir espace . et -
    return : (datetime) la date de naissance
    """
    numero_national = clean_string(numero_national)
    date = numero_national[:6]
    return datetime.datetime.strptime(date, "%y%m%d")


@register.filter
def is_valid_tva_number(tva_number, formatage=True):
    """
    tva_number : (str) numéro de tva BE0000000097
    formatage : (bool) True/False
    return : (bool) True si le numéro est valide
    """
    # si formatage alors enlève les espaces, points et tirets
    if formatage:
        tva_number = clean_string(tva_number)

    if not tva_number[:2].upper() == "BE":
        return False
    if not len(tva_number) == 12:
        if len(tva_number) == 11:
            tva_number = tva_number[:2] + "0" + tva_number[2:]
        else:
            return False
    if re.match(r"^\d{10}$", tva_number[2:]):
        int_value = int(tva_number[2:10])
        check_digit = int(int_value / 97) * 97
        if (97 - (int_value - check_digit)) == int(tva_number[10:12]):
            return True
        else:
            return False


@register.filter
def liste_type_rdv_plusieurs_personnes(value):
    """
    Anciennement liste_type_general_rdv.py
    value : (str) url api liste des types de rendez-vous
    return : (list[str]) liste des différent type de rendez-vous sans - x personnes
    """
    headers = {"Accept": "application/json"}
    liste = requests.get(value, headers=headers).json()
    return list(set([re.sub(r" (pour|-) [0-9]+ personne(s)?$", "", x["text"]) for x in liste["data"]]))


@register.filter
def liste_type_rdv_nombres_personnes(value, arg):
    """
    Anciennement liste_type_rdv.py
    value : (str) url api liste des type de rendez-vous
    arg : (str) type de rendez-vous
    return : (list[str]) liste des rendez-vous de type arg
    """
    headers = {"Accept": "application/json"}
    liste = requests.get(value, headers=headers).json()

    return [x for x in liste["data"] if arg in x["text"]]


@register.filter
def calcul_total_abonnement_stationnement(fields_bloc):
    """
    Anciennement fields_bloc.py
    fields_bloc : (list[dict]) Bloc de champ Abonnements de stationnement données bénéficiaires
    return : (Decimal) addition des entrées price
    """
    total = 0

    for field in fields_bloc:
        for value in field.values():
            if isinstance(value, dict):
                total += Decimal(value.get("price"))

    return total


@register.filter
def autorisation_voyage_enfants_concernes(lst_enfants_concernes):
    """
    Anciennement autorisation_voyage_enfants_concernes.py
    lst_enfants_concernes : (list)
    return : (str)
    """
    enfants_concernes = ""
    if lst_enfants_concernes is not None:
        for e in lst_enfants_concernes:
            enfants_concernes = enfants_concernes + "-  " + e[0] + " né(e) à " + e[1] + " le " + e[2] + "\r\n"

    return enfants_concernes