from django.db.models import Sum, Q
from django.db.models.signals import post_save, post_delete
from common.helpers import get_organization_by_user
from rest_framework.exceptions import APIException
from django.dispatch import receiver
from .models import (
    QuotaDistribution,
    Quota,
    Product,
    ProductStats,
    QuotaStats
)
from apps.warehouse.models import (
    InventoryQuotaSaleTransaction,
    InventoryEntry
)
from django.db import models
from crum import get_current_user


def recalculate_remaining_amount(quota):
    """ calculate remaining weight from distribution """
    total_distributed = quota.distributions_assigned.filter(
        parent_distribution__isnull=True,
    ).aggregate(
        total=Sum('weight')
    )['total'] or 0

    quota.remaining_weight = quota.quota_weight - total_distributed
    quota.quota_distributed = total_distributed
    quota.save(update_fields=["remaining_weight", "quota_distributed"])


def remaining_distribution_weight(instance: QuotaDistribution):
    """ calculate remaining & distributed weight from distribution """

    total_children_weight = instance.children.aggregate(
        total=Sum('weight')
    )['total'] or 0

    # total warehouse inventory entry
    total_entry = instance.inventory_entry.aggregate(
        total=Sum('weight')
    )['total'] or 0

    instance.remaining_weight = instance.weight - total_children_weight - total_entry
    instance.distributed = total_children_weight
    instance._from_signal = True
    instance.save(update_fields=['remaining_weight', 'distributed'])

    if instance.parent_distribution:
        remaining_distribution_weight(instance.parent_distribution)


@receiver(post_save, sender=QuotaDistribution)
@receiver(post_delete, sender=QuotaDistribution)
def update_quota_remaining(sender, instance, **kwargs):
    recalculate_remaining_amount(instance.quota)

    # if _from_signal=True prevent from maximum recursion loop
    if getattr(instance, '_from_signal', False):
        return

    # when delete object, prevent from update fields error
    if kwargs.get('signal') == post_delete:
        if instance.parent_distribution:
            remaining_distribution_weight(instance.parent_distribution)
    else:
        remaining_distribution_weight(instance)


def update_product_stats(instance: Product, distribution: QuotaDistribution = None):
    """ update all stats of product  """

    organization = get_organization_by_user(get_current_user())

    if ProductStats.objects.filter(
            organization=organization,
            product=instance,
            sale_unit=distribution.quota.sale_unit.unit
    ):
        stat = instance.stats.get(
            organization=organization,
            product=instance,
            sale_unit=distribution.quota.sale_unit.unit
        )
    else:
        stat = ProductStats.objects.create(
            product=instance,
            organization=organization,
            sale_unit=distribution.quota.sale_unit.unit
        )

    # number of quotas

    quota = Quota.objects.filter(
        Q(
            distributions_assigned__in=QuotaDistribution.objects.filter(
                Q(assigned_organization=organization) |
                Q(assigner_organization=organization) &
                Q(parent_distribution__isnull=True)

            )
        ) |
        Q(registerer_organization=organization),
        product=instance
    ).distinct()

    quotas_count = quota.count()  # noqa

    total_quotas_weight = quota.aggregate(  # noqa
        total=models.Sum('quota_weight')
    )['total'] or 0

    # total weight of product that assigned in quota
    active_quotas_weight = quota.filter(is_closed=False).aggregate(
        total=models.Sum('quota_weight')
    )['total'] or 0

    closed_quotas_weight = quota.filter(is_closed=True).aggregate(  # noqa
        total=models.Sum('quota_weight')
    )['total'] or 0

    # total remaining weight of product quotas
    total_remaining_quotas_weight = quota.filter(is_closed=False).aggregate(  # noqa
        total=models.Sum('remaining_weight')
    )['total'] or 0

    received_distribution_weight = QuotaDistribution.objects.filter(
        quota__product_id=instance.id,
        quota__is_closed=False,
        quota__sale_unit=distribution.quota.sale_unit,
        assigned_organization=organization,
        parent_distribution__isnull=True
    )

    received_distribution_number = received_distribution_weight.count()

    received_distribution_weight = received_distribution_weight.aggregate(
        total_weight=models.Sum('weight')
    )['total_weight'] or 0

    # product total distributed weight from quota
    given_distribution_weight = QuotaDistribution.objects.filter(
        quota__product_id=instance.id,
        quota__is_closed=False,
        quota__sale_unit=distribution.quota.sale_unit,
        assigner_organization=organization,
        parent_distribution__isnull=True
    )

    given_distribution_number = given_distribution_weight.count()
    given_distribution_weight = given_distribution_weight.aggregate(
        total_weight=models.Sum('weight')
    )['total_weight'] or 0

    if received_distribution_weight > 0:
        distribution_weight_balance = received_distribution_weight - given_distribution_weight
    else:
        distribution_weight_balance = given_distribution_weight

    # total sold of product from quota
    total_sold = QuotaDistribution.objects.filter(
        quota__product_id=instance.id,
        quota__is_closed=False,
        quota__sale_unit=distribution.quota.sale_unit,
        assigned_organization=organization
    ).aggregate(total_sold=models.Sum('been_sold'))['total_sold'] or 0

    # total entry from product to inventory
    total_warehouse_entry = QuotaDistribution.objects.filter(
        quota__product_id=instance.id,
        quota__is_closed=False,
        quota__sale_unit=distribution.quota.sale_unit,
        assigned_organization=organization
    ).aggregate(total_entry=models.Sum('warehouse_entry'))['total_entry'] or 0

    stat.quotas_number = quotas_count
    stat.active_quotas_weight = active_quotas_weight
    stat.closed_quotas_weight = closed_quotas_weight
    stat.total_quota_weight = total_quotas_weight
    stat.total_quota_remaining = total_remaining_quotas_weight
    stat.total_remaining_distribution_weight = distribution_weight_balance
    stat.received_distribution_weight = received_distribution_weight
    stat.given_distribution_weight = given_distribution_weight
    stat.received_distribution_number = received_distribution_number
    stat.given_distribution_number = given_distribution_number
    stat.total_warehouse_entry = total_warehouse_entry
    stat.total_sold = total_sold
    stat.save(update_fields=[
        "quotas_number",
        "active_quotas_weight",
        "closed_quotas_weight",
        "total_quota_weight",
        "total_quota_remaining",
        "total_remaining_distribution_weight",
        "received_distribution_weight",
        "given_distribution_weight",
        "received_distribution_number",
        "total_warehouse_entry",
        "total_sold",
    ])


def update_quota_stats(instance: Quota):
    """ update all stats of quota """

    if hasattr(instance, 'stats'):
        stat = instance.stats
    else:
        stat = QuotaStats.objects.create(quota=instance)

    total_distributed = instance.quota_distributed
    total_remaining = instance.remaining_weight

    # total entry to inventory from quota
    total_inventory = InventoryEntry.objects.filter(
        distribution__quota=instance
    ).aggregate(
        total_inventory=models.Sum('weight')
    )['total_inventory'] or 0

    # total sale of distributions from quota
    total_sale = instance.distributions_assigned.filter(
        quota__is_closed=False
    ).aggregate(total_sale=models.Sum('been_sold'))['total_sale'] or 0

    stat.total_distributed = total_distributed
    stat.remaining = total_remaining
    stat.total_inventory = total_inventory
    stat.total_sale = total_sale
    stat.save(update_fields=[
        "total_distributed",
        "remaining",
        "total_inventory",
        "total_sale",
    ])


@receiver([post_save, post_delete], sender=QuotaDistribution)
@receiver([post_save, post_delete], sender=InventoryQuotaSaleTransaction)
def update_stats_on_change(sender, instance, **kwargs):
    if sender == QuotaDistribution:
        update_product_stats(instance.quota.product, instance)
        update_quota_stats(instance.quota)
    elif sender == InventoryQuotaSaleTransaction:
        update_product_stats(instance.quota_distribution.quota.product, instance.quota_distribution)
        update_quota_stats(instance.quota_distribution.quota)
