# --------------------------------- views.py --------------------------------- #

from django.db import models
from django.db.models import F, FloatField
from rest_framework import mixins
from rest_framework import viewsets
from rest_framework.permissions import IsAuthenticated

from backend.media_planer.models import Product, ProductContent, ProductPlan
from .serializers import BaseProductContentSerializers, BaseProductSerializer, BaseProductPlanSerializer


class ProductPlanViewSet(mixins.UpdateModelMixin,
                         mixins.DestroyModelMixin,
                         mixins.ListModelMixin,
                         mixins.CreateModelMixin,
                         viewsets.GenericViewSet):
    serializer_class = BaseProductPlanSerializer
    permission_classes = (IsAuthenticated,)

    def get_queryset(self):
        total_dirty_contracts_count = models.Sum(F('products__dirty_contracts_count'))

		# ANNOTATE FIELDS FROM Product MODEL

        return ProductPlan.objects.filter(creator=self.request.user).prefetch_related('products').annotate(
            total_dirty_contracts_count=total_dirty_contracts_count
        )


class ProductViewSet(mixins.UpdateModelMixin,
                     mixins.DestroyModelMixin,
                     mixins.ListModelMixin,
                     mixins.CreateModelMixin,
                     viewsets.GenericViewSet):
    serializer_class = BaseProductSerializer
    permission_classes = (IsAuthenticated,)
    queryset = Product.objects.all().select_related('related_plan')

    def get_queryset(self):
        days_to_meeting = models.Avg(F('related_plan__days_to_meeting'), output_field=FloatField())
        days_in_month = models.Avg(F('related_plan__days_in_month'), output_field=FloatField())
        dirty_contracts_count = models.Avg(models.F('dirty_contracts_count'), output_field=FloatField())
        dirty_leads_count = 100 * dirty_contracts_count / F('dirty_cr')
        leads_count = models.Sum(F('values__lead_value'), output_field=FloatField())
        contracts_count = models.Sum(F('values__contract_value'), output_field=FloatField())
        ext_incr_lead_pay_count = days_in_month * leads_count / days_to_meeting
        ext_incr_contact_pay_count = days_in_month * contracts_count / days_to_meeting
        ext_incr_lead_pay_percent = 100 * dirty_leads_count / ext_incr_lead_pay_count
        ext_incr_contact_pay_percent = 100 * dirty_contracts_count / ext_incr_contact_pay_count
        ext_dirty_cr = 100 * contracts_count / leads_count
        desired_lead_pay_count = models.Avg(F('desired_lead_pay_count'), output_field=FloatField())
        desired_contract_pay_count = desired_lead_pay_count * models.Avg(F('desired_cr'), output_field=FloatField())
        desired_lead_pay_percent = desired_lead_pay_count / dirty_leads_count * 100
        desired_contract_pay_percent = 100 * desired_contract_pay_count / dirty_contracts_count

        return self.queryset.filter(
            related_plan__pk=self.kwargs['plan_pk'],
            related_plan__creator=self.request.user
        ).annotate(
            dirty_leads_count=dirty_leads_count,
            leads_count=leads_count,
            contracts_count=contracts_count,
            ext_incr_lead_pay_count=ext_incr_lead_pay_count,
            ext_incr_lead_pay_percent=ext_incr_lead_pay_percent,
            ext_incr_contact_pay_count=ext_incr_contact_pay_count,
            ext_dirty_cr=ext_dirty_cr,
            ext_incr_contact_pay_percent=ext_incr_contact_pay_percent,
            desired_contract_pay_count=desired_contract_pay_count,
            desired_contract_pay_percent=desired_contract_pay_percent,
            desired_lead_pay_percent=desired_lead_pay_percent
        )


class ProductContentViewSet(mixins.UpdateModelMixin,
                            mixins.DestroyModelMixin,
                            mixins.ListModelMixin,
                            mixins.CreateModelMixin,
                            viewsets.GenericViewSet):
    serializer_class = BaseProductContentSerializers
    permission_classes = (IsAuthenticated,)

    def get_queryset(self):
        return ProductContent.objects.filter(related_product__pk=self.kwargs['product_pk'])

# --------------------------------- models.py --------------------------------- #

import logging

from django.conf import settings
from django.db import models
from django.db.models import FloatField
from django.utils.translation import ugettext_lazy as _

__all__ = ('Product',
           'ProductContent',
           'ProductPlan')

logger = logging.getLogger(name=__name__)


class ProductPlan(models.Model):
    creator = models.ForeignKey(
        settings.AUTH_USER_MODEL, on_delete=models.CASCADE, verbose_name=_('Creator'), null=True
    )
    days_in_month = models.IntegerField(
        blank=True, null=True, verbose_name=_('Days in month')
    )
    days_to_meeting = models.IntegerField(
        blank=True, null=True, verbose_name=_('Days to meeting')
    )

    @property
    def products_count(self):
        return self.products.count()

    def __str__(self):
        return self.id

    class Meta:
        ordering = ('id',)
        verbose_name = _('Product plan')
        verbose_name_plural = _('Product plans')


class Product(models.Model):
    related_plan = models.ForeignKey(
        ProductPlan, on_delete=models.CASCADE, verbose_name=_('Related product plan'), related_name='products',
        null=True
    )
    desired_lead_pay_count = models.IntegerField(
        default=0, verbose_name=_('Desired pay count')
    )
    desired_cr = models.FloatField(
        default=0, verbose_name=_('Desired CR')
    )
    name = models.CharField(
        max_length=200, blank=True, null=True, verbose_name=_('Name')
    )
    lead_custom_name = models.CharField(
        max_length=100, blank=True, null=True, verbose_name=_('Lead custom name')
    )
    contract_custom_name = models.CharField(
        max_length=100, blank=True, null=True, verbose_name=_('Contract custom name')
    )
    dirty_contracts_count = models.IntegerField(
        default=0, verbose_name=_('Contracts count')
    )
    dirty_cr = models.FloatField(default=0, verbose_name=_('Dirty CR'))

    @property
    def values_count(self):
        return self.values.count()

    def __str__(self):
        return self.name

    class Meta:
        ordering = ('id',)
        verbose_name = _('Product')
        verbose_name_plural = _('Products')


class ProductContent(models.Model):
    lead_value = models.IntegerField(
        default=0, verbose_name=_('Lead value')
    )
    contract_value = models.IntegerField(
        default=0, verbose_name=_('Contract value')
    )
    date = models.DateTimeField(
        auto_now_add=True, verbose_name=_('Data')
    )
    related_product = models.ForeignKey(
        Product, on_delete=models.CASCADE, related_name='values',
    )

    def __str__(self):
        return 'Product %s: Contracts: %i, Leads: %i' % (
            self.related_product.name, self.contract_value, self.lead_value)

    class Meta:
        ordering = ('id',)
        verbose_name = _('Product content')
        verbose_name_plural = _('Product contents')


# --------------------------------- serializers.py --------------------------------- #

from rest_framework import serializers
from ..card.utils.serializers import get_obj_or_raise_error

from backend.media_planer.models import Product, ProductContent, ProductPlan


class BaseProductPlanSerializer(serializers.ModelSerializer):
    creator = serializers.HiddenField(
        default=serializers.CurrentUserDefault(),
    )
    products_count = serializers.IntegerField(default=0, read_only=True)
    total_dirty_leads_count = serializers.IntegerField(default=0, read_only=True)
    total_dirty_contracts_count = serializers.IntegerField(default=0, read_only=True)

    class Meta:
        model = ProductPlan
        fields = '__all__'


class BaseProductSerializer(serializers.ModelSerializer):
    dirty_leads_count = serializers.FloatField(default=0, read_only=True)
    leads_count = serializers.IntegerField(default=0, read_only=True)
    contracts_count = serializers.IntegerField(default=0, read_only=True)
    ext_incr_lead_pay_count = serializers.IntegerField(default=0, read_only=True)
    ext_incr_lead_pay_percent = serializers.IntegerField(default=0, read_only=True)
    ext_incr_contact_pay_count = serializers.IntegerField(default=0, read_only=True)
    ext_incr_contact_pay_percent = serializers.IntegerField(default=0, read_only=True)
    ext_dirty_cr = serializers.IntegerField(default=0, read_only=True)
    desired_contract_pay_count = serializers.IntegerField(default=0, read_only=True)
    desired_contract_pay_percent = serializers.FloatField(default=0, read_only=True)
    desired_lead_pay_percent = serializers.FloatField(default=0, read_only=True)

    def create(self, validated_data):
        get_obj_or_raise_error(validated_data, self.context, model=ProductPlan, pk_args='plan_pk')
        return super(BaseProductSerializer, self).create(validated_data)

    class Meta:
        model = Product
        exclude = ('related_plan',)


class BaseProductContentSerializers(serializers.ModelSerializer):
    def create(self, validated_data):
        get_obj_or_raise_error(validated_data, self.context, model=Product, pk_args='product_pk')
        return super(BaseProductContentSerializers, self).create(validated_data)

    class Meta:
        model = ProductContent
        exclude = ('related_product',)