# coding=utf-8

from django.db.models import Sum
from django.shortcuts import render, get_object_or_404
from django.contrib.auth.decorators import login_required

from collections import OrderedDict

from django.views.decorators.http import require_http_methods
from django.http import HttpResponse, HttpResponseRedirect
from django.urls import reverse
import decimal

from .models import (
    # Transaction,
    Event,
)

from .forms import EventForm

from comptabilite.models import Transaction


def append_to_dictionnary(transaction, dictionnary, previous_date=None):
    """
    Ajoute au dictionnaire le montant de la transaction, soit en l'ajoutant à une clé déjà présente
    soit en créant un nouvelle clé.
    """
    date = transaction.registrationDate.date()
    amount = transaction.amount

    if date in dictionnary:
        if transaction.transaction_type.transaction_type == 1:
            dictionnary[date] += amount
        else:
            dictionnary[date] -= amount
    else:
        if previous_date is not None:
            if transaction.transaction_type.transaction_type == 1:
                dictionnary[date] = dictionnary[previous_date] + amount
            else:
                dictionnary[date] = dictionnary[previous_date] - amount
        else:
            if transaction.transaction_type.transaction_type == 1:
                dictionnary[date] = amount
            else:
                dictionnary[date] = -amount

    return date


def __compute_sum_amount(transaction_list, with_simulated=None):
    """

    """
    if with_simulated is None:
        total = sum(
            [
                transaction.totalAmount
                for transaction in transaction_list
                if not transaction.is_simulated
                and transaction.transaction_type.transaction_type == 1
            ]
        )
        total -= sum(
            [
                transaction.totalAmount
                for transaction in transaction_list
                if not transaction.is_simulated
                and transaction.transaction_type.transaction_type == 0
            ]
        )
    else:
        total = sum(
            [
                transaction.totalAmount
                for transaction in transaction_list
                if transaction.transaction_type.transaction_type == 1
            ]
        )
        total -= sum(
            [
                transaction.totalAmount
                for transaction in transaction_list
                if transaction.transaction_type.transaction_type == 0
            ]
        )

    return total


@login_required
@require_http_methods(["GET"])
def event_details(request, event_id):
    """
    Renvoie l'évènement, toutes les lignes de comptabilité associées et la somme de ces lignes.
    """
    event = Event.objects.select_related().get(pk=event_id)
    transaction_list = event.transactions.all().order_by("-registrationDate")

    sum_recette = event.transactions.filter(
        transaction_type__transaction_type=1
    ).aggregate(Sum("totalAmount"))["totalAmount__sum"]
    sum_depense = event.transactions.filter(
        transaction_type__transaction_type=0
    ).aggregate(Sum("totalAmount"))["totalAmount__sum"]

    if not isinstance(sum_recette, decimal.Decimal):
        sum_recette = 0

    if not isinstance(sum_depense, decimal.Decimal):
        sum_depense = 0

    total_simulated_amount = sum_recette - sum_depense

    nonsimulated_sum_recette = event.transactions.filter(
        transaction_type__transaction_type=1, is_simulated=False
    ).aggregate(Sum("totalAmount"))["totalAmount__sum"]
    nonsimulated_sum_depense = event.transactions.filter(
        transaction_type__transaction_type=0, is_simulated=False
    ).aggregate(Sum("totalAmount"))["totalAmount__sum"]

    if not isinstance(nonsimulated_sum_recette, decimal.Decimal):
        nonsimulated_sum_recette = 0

    if not isinstance(nonsimulated_sum_depense, decimal.Decimal):
        nonsimulated_sum_depense = 0

    total_amount = nonsimulated_sum_recette - nonsimulated_sum_depense

    previous_date = None
    date_sum = OrderedDict()
    previous_date_with_simulated = None
    date_sum_with_simulated = OrderedDict()

    for transaction in transaction_list:
        previous_date_with_simulated = append_to_dictionnary(
            transaction, date_sum_with_simulated, previous_date_with_simulated
        )

        if not transaction.is_simulated:
            previous_date = append_to_dictionnary(transaction, date_sum, previous_date)

    if len(date_sum) == len(date_sum_with_simulated):
        date_sum_with_simulated = None
        # total_amount = total_simulated_amount
    else:
        # total_amount = __compute_sum_amount(transaction_list)
        pass

    context = {
        "event": event,
        "transaction_list": transaction_list,
        "total_Amount": total_amount,
        "total_simulated_Amount": total_simulated_amount,
        "date_sum": date_sum,
        "date_sum_simulated": date_sum_with_simulated,
        "sum_recette": sum_recette,
        "sum_depense": sum_depense,
        "nonsimulated_sum_recette": nonsimulated_sum_recette,
        "nonsimulated_sum_depense": nonsimulated_sum_depense,
    }

    return render(request, "event/details.html", context)


@login_required
@require_http_methods(["GET"])
def event_listing(request):
    """
    Renvoie la liste de tous les évènements.
    """
    event_list = Event.objects.all().order_by("-date_begin")
    context = {"events": event_list}
    return render(request, "event/listing.html", context)


@login_required
@require_http_methods(["GET", "POST"])
def event_create_or_update(request, event_id=None):
    """ Création ou modificatin d'une event.

    Args:
        event_id (int): identifiant d'une event.
    """

    if event_id:
        event = get_object_or_404(Event, pk=event_id)
    else:
        event = None

    if request.method == "POST":
        form = EventForm(request.POST, instance=event)

        if form.is_valid():
            event = form.save()
            return HttpResponseRedirect(reverse("event_details", args=(event.pk, )))

    else:
        form = EventForm(instance=event)

    context = {"form": form, "event_id": event_id}
    return render(request, "event/create.html", context)