from decimal import Decimal
from django.db.models import Sum

from .models import (
    Transaction,
    TransactionType,
    Patrimony,
    PatrimonyType,
    RightEngagementType,
    RightEngagement,
)

from .utils import zero_or_value


def get_transactions_and_sums_for_year_and_type(accounting_year, transaction_type_id):
    """
    Récupère les transactions associées à une année et un type et additionne les valeurs obtenues.

    Args:
        accounting_year (int): année comptable
        transaction_type_id (int): type de transaction

    Returns:
        (dict)
    """
    transactions_list = (
        Transaction.objects.by_year(accounting_year)
        .filter(transaction_type__transaction_type=transaction_type_id)
        .order_by("registrationDate")
    )
    sum_bank_amount = 0
    sum_box_amount = 0
    sum_total_amount = 0

    for transaction in transactions_list:
        sum_bank_amount += transaction.bkAmount
        sum_box_amount += transaction.bxAmount
        sum_total_amount += transaction.totalAmount

    return {
        "transactions_list": transactions_list,
        "sum_bank_amount": sum_bank_amount,
        "sum_box_amount": sum_box_amount,
        "sum_total_amount": sum_total_amount,
    }


def get_transactions_totalamount_sum_value_for_type(accounting_year, transaction_type):
    """
    Récupère les transactions associées à une année et un type et additionne le montant total des
    records obtenus.

    Args:
        accounting_year (int): année comptable
        transaction_type (id): type de transaction

    Returns:
        (int): somme totale
    """
    return zero_or_value(
        list(
            Transaction.objects.by_year(accounting_year)
            .filter(
                transaction_type=transaction_type, is_simulated=False, is_done=True,
            )
            .aggregate(Sum("totalAmount"))
            .values()
        )[0]
    )


def get_transactions_totalamount_sum_value_for_parenttype(
    accounting_year, transaction_type
):
    """
    Récupère les transactions associées à une année et un type et additionne le montant total des
    records obtenus.

    Args:
        accounting_year (int): année comptable
        transaction_type (id): type de transaction

    Returns:
        (int): somme totale
    """
    return zero_or_value(
        list(
            Transaction.objects.by_year(accounting_year)
            .filter(
                transaction_type__parent=transaction_type,
                is_simulated=False,
                is_done=True,
            )
            .aggregate(Sum("totalAmount"))
            .values()
        )[0]
    )


def get_transactiontypes_and_total_amount_transactions(
    accounting_year, transactiontype_id
):
    """
    Récupère tous les types de transactions qui existent pour, pour chacun d'eux récupère toutes
    les transactions qui sont `effectuées` et non `simulées` et va additionner les montants totaux
    par type de transaction.

    Args:
        accounting_year (int): année comptable
        transactiontype_id (int): type de transaction

    Returns:
        (dict): ensemble des types de transaction et somme totale
    """

    i = 0
    total_transactiontypes_value = 0
    transactiontypes_info_list = []
    transactiontypes_list = TransactionType.objects.filter(
        transaction_type=transactiontype_id, parent=None
    ).order_by("order")

    for transaction_type in transactiontypes_list:
        j = 0

        sum_value = get_transactions_totalamount_sum_value_for_type(
            accounting_year, transaction_type
        )
        transactiontypes_info_list.append(
            {
                "label": transaction_type.label,
                "category": transaction_type.category,
                "parent": None,
                "total_transactiontypes_value": sum_value,
                "id": transaction_type.id,
            }
        )

        transactiontype_subtype = TransactionType.objects.filter(
            parent=transaction_type
        ).order_by("order")

        for subtype in transactiontype_subtype:
            subtype_sum_value = get_transactions_totalamount_sum_value_for_type(
                accounting_year, subtype
            )

            transactiontypes_info_list.append(
                {
                    "label": subtype.label,
                    "category": subtype.category,
                    "parent": subtype.parent,
                    "total_transactiontypes_value": subtype_sum_value,
                    "id": subtype.id,
                }
            )

            transactiontypes_info_list[i][
                "total_transactiontypes_value"
            ] += subtype_sum_value
            j += 1

        total_transactiontypes_value += transactiontypes_info_list[i][
            "total_transactiontypes_value"
        ]
        i += j + 1

    return {
        "transactiontypes_info_list": transactiontypes_info_list,
        "total": total_transactiontypes_value,
    }


def get_transactiontype_and_sum_for_spf_export(accounting_year, transaction_type_id):
    """
    Récupère tous les types de transactions sans parent pour une année et un type donnés. Ensuite,
    pour chacun d'eux elle va sélectionner toutes les transactions qui sont `effectuées` et `non
    simulées` appartenant à ce type de transactions et va ensuite additionner les montants totaux
    du type de transaction.

    Args:
        accounting_year (int): année comptable
        transaction_type_id (int): type de transaction

    Returns:
        (dict): ensemble des types de transaction et somme totale
    """

    sum_total_transaction = 0
    transactiontypes_info = []
    transactiontypes_list = TransactionType.objects.filter(
        transaction_type=transaction_type_id, parent=None
    ).order_by("order")

    for transactiontype in transactiontypes_list:
        sum_total_amount = get_transactions_totalamount_sum_value_for_type(
            accounting_year, transactiontype
        ) + get_transactions_totalamount_sum_value_for_parenttype(
            accounting_year, transactiontype
        )
        sum_total_transaction += sum_total_amount

        transactiontypes_info.append(
            {
                "label": transactiontype.label,
                "sum_total_amount": sum_total_amount
                if sum_total_amount != 0
                else Decimal(0.00),
                "category": transactiontype.category,
            }
        )

    return {
        "transaction_type_info": transactiontypes_info,
        "sum_total_transaction": sum_total_transaction,
    }


def get_right_engagement_and_sump_spf(accounting_year, category):
    """
    Récupère tous les types de droits et d'engagements et l'ensemble lignes correspondantes et
    additionne les montants.

    Args:
        accounting_year (int): année comptable
        category (int): choix de la catégorie (i.e. "droits" ou "engagements")

    Returns:
        (int): somme totale
    """

    right_engagement_info = []
    right_engagement_list = RightEngagementType.objects.filter(
        category=category
    ).order_by("order")

    for right_engagement in right_engagement_list:
        tmp = list(
            RightEngagement.objects.by_year(accounting_year)
            .filter(r_e_type=right_engagement)
            .aggregate(Sum("amount"))
            .values()
        )[0]
        right_engagement_info.append(
            [right_engagement.label, tmp if tmp is not None else Decimal(0.00)]
        )

    return right_engagement_info


def get_asset_liability_and_sump_spf(accounting_year, category):
    """
    Récupère tous les types de droits et dettes. Pour chacun de ces types, va chercher l'ensemble
    lignes correspondantes et additionne les montants.

    Args:
        accounting_year (int): année comptable
        category (int): choix de la catégorie (i.e. "droits" ou "engagements")

    Returns:
        (int): somme totale
    """

    asset_liability_info = []
    asset_liability_list = PatrimonyType.objects.filter(category=category).order_by(
        "order"
    )

    for item in asset_liability_list:
        tmp = list(
            Patrimony.objects.by_year(accounting_year)
            .filter(patrimony_type=item)
            .aggregate(Sum("totalAmount"))
            .values()
        )[0]
        asset_liability_info.append(
            [item.label, tmp if tmp is not None else Decimal(0.00)]
        )

    return asset_liability_info