from django.db import models
from django.db.models.signals import post_save
from django.dispatch import receiver
from quotation.models import Invoice, Customer_Payment, Order,Order_Item,Technician_Assigned_Order_Item
from technician.models import Job_Time,Notification
from geopy.geocoders import Nominatim
from technician.models import Technician_Assigned_Order_Item, Notification
from django.utils import timezone
from product.models import SerialNumber,Product
from service.models import Question,Answer,Checklist
# from technician.models import send_notification_to_technician
from django.contrib.messages import success
from celery import shared_task
from django.db.models import Sum
from decimal import Decimal

def allocate_serial_number(order_item,invoice,customer):
    if order_item.is_trade == 0:
        open_serial_numbers = SerialNumber.objects.filter(
            product=order_item.product,
            status=SerialNumber.UNALLOCATED,
            serial_number__isnull=False).order_by('created_at').all()
        if open_serial_numbers:
            open_serial_number = open_serial_numbers[0]  
            order_item.serial_number = open_serial_number
            if open_serial_number.bill:
                order_item.supplier=open_serial_number.bill.supplier
                order_item.bill=open_serial_number.bill
            order_item.status=open_serial_number.tracking_status
            
            order_item.save()
            open_serial_number.status = SerialNumber.ALLOCATED
            open_serial_number.invoice=invoice
            open_serial_number.customer=customer
            open_serial_number.save()
        else:
            order_item.serial_number = None
            order_item.save()
         
         

@receiver(post_save, sender=Customer_Payment)
def create_order_after_payment(sender,instance, created, **kwargs):
    if created and instance.paid_amount and instance.paid_amount > 0:
        # Assuming you have a float and a Decimal
        float_value = 0.3
        float_as_decimal = Decimal(str(float_value))
        invoice = instance.invoice
        total_paid_amount = Customer_Payment.objects.filter(invoice=invoice).aggregate(total_paid=Sum('paid_amount'))['total_paid']
        
        if total_paid_amount and total_paid_amount >= float_as_decimal * invoice.total:
            existing_order = Order.objects.filter(invoice=invoice).first()
            if not existing_order:
                order = Order.objects.create(invoice=invoice, created_by=instance.created_by)
                # address = order.invoice.customer.city
                # geolocator = Nominatim(user_agent="address__geocoder")
                # location = geolocator.geocode(address)
                
                order_identifier = 1 
                for item in invoice.invoice_items.all():
                    for j in range(item.qty):
                        if item.is_trade_product == 1:
                            order_item = Order_Item.objects.create(
                                order=order,
                                order_identifier=order_identifier, 
                                product=item.product,
                                cost_per_unit=item.cost_per_unit,
                                qty=1, 
                                status=4,
                                created_by=instance.created_by,
                                subtotal=item.subtotal,
                                is_trade=1,
                                # latitude=location.latitude,
                                # longitude=location.longitude
                                latitude=37.4219983,
                                longitude=-122.084
                            )
                            order_identifier += 1
                            invoice=order.invoice
                            customer=order.invoice.customer
                            allocate_serial_number(order_item, invoice, customer)
                        else:
                            order_item = Order_Item.objects.create(
                                order=order,
                                order_identifier=order_identifier, 
                                product=item.product,
                                cost_per_unit=item.cost_per_unit,
                                qty=1,  
                                is_trade=0,
                                created_by=instance.created_by,
                                subtotal=item.subtotal,
                                # latitude=location.latitude,
                                # longitude=location.longitude
                                latitude=37.4219983,
                                longitude=-122.084
                            )
                            order_identifier += 1
                            invoice=order.invoice
                            customer=order.invoice.customer
                            allocate_serial_number(order_item, invoice, customer)


@receiver(post_save, sender=Technician_Assigned_Order_Item)
def send_notification(sender, instance, created, **kwargs):
    if created:
        Notification.objects.create(technician=instance.technician, order_id=instance.order_item.order.id)


@receiver(post_save, sender=Technician_Assigned_Order_Item)
def create_question_answer_after_assignment(sender, instance, created, **kwargs):
    print(f"Signal received for instance id: {instance.id}, created: {created}")

    if created:
        service_type=instance.order_item.service_type
        print('deepak')
        checklists = Checklist.objects.filter(type=service_type,)
        print(checklists)
        for checklist in checklists:
            print(checklist)
            questions = Question.objects.filter(checklist=checklist,product=instance.order_item.product)
            print(questions)
            for question in questions:
                if question.checklist.type == 1:
                    Answer.objects.create(
                    technician_assigned_job=instance,
                    question=question,
                    is_installation=True
                )
                else:
                    Answer.objects.create(
                    technician_assigned_job=instance,
                    question=question,
                )
        checklist = Checklist.objects.filter(type=3)
        questions = Question.objects.filter(checklist__in=checklist)  # Use __in to filter by a queryset
        for question in questions:
            Answer.objects.create(
                technician_assigned_job=instance,
                question=question,
                is_signature=True
            )

        if service_type == 2:   
            
            questionWarrenty = Question.objects.get(id=178)
            if questionWarrenty:
                Answer.objects.create(
                            technician_assigned_job=instance,
                            question=questionWarrenty,
                            is_warrenty=True,
                            is_installation=False
                        )
            
            questionPartRequired = Question.objects.get(id=137)
            if questionPartRequired:
                Answer.objects.create(
                            technician_assigned_job=instance,
                            question=questionPartRequired,
                            is_parts=True,
                            is_installation=False
                        )
                        
            # questionChecklistRequired = Question.objects.get(checklist__type=3)
            # if questionChecklistRequired:
            #     Answer.objects.create(
            #                 technician_assigned_job=instance,
            #                 question=questionPartRequired,
            #                 is_signature=True
            #             )
            # questionInstallationRequired = Question.objects.get(checklist__type=1)
            # if questionInstallationRequired:
            #     Answer.objects.create(
            #                 technician_assigned_job=instance,
            #                 question=questionPartRequired,
            #                 is_installation=True
            #             )
                        
            
                        




    
 