import requests
from django.shortcuts import redirect, render
from django.contrib import messages
from django.conf import settings
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
from django.contrib.auth.decorators import login_required
from urllib.parse import urlencode
import json
from authentication.models import User
from leads.models import Lead,Leadnote,LeadAttachmentPhotos,LeadAttachmentFiles
from myobconnect.models import MyobModel
from django.contrib.auth.hashers import make_password
from django.core import serializers
from myobconnect.views import refresh_token
from django.utils import timezone
from django.db.models import Q

import string

import urllib.parse

from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from django.utils.decorators import method_decorator
from django.views import View

from quotation.models import Invoice,Quotation
from django.db.models import CharField, Value
from django.db.models.functions import Concat
from authentication.models import ActivityLog
from authentication.decorators import is_admin, is_sales, is_technician, is_customer,is_superuser
from django.contrib.auth.decorators import user_passes_test
from django.shortcuts import get_object_or_404
import os
from django.http import HttpResponse
from django.template.loader import render_to_string
from django.core.mail import EmailMessage
from django.contrib.auth.hashers import make_password
from dotenv import load_dotenv, find_dotenv
from authentication.models import User,Role
import random
from .models import Lead,Lead_Quote
from django.urls import reverse
load_dotenv(find_dotenv())
myob_customer_freightaxcode = os.environ.get('MYOB_Customer_FreightTaxCode')
myob_customer_taxcode = os.environ.get('MYOB_Customer_TaxCode')
from django.utils.timezone import localdate,now
from django.db.models import Max,Min
from django.db.models import Subquery, OuterRef
import csv
from product.models import ProductCategory,Product,OtherImage,SerialNumber

@method_decorator(csrf_exempt, name='dispatch')
class MarkNotesReadView(View):
    def post(self, request):
        today = localdate()  
        if request.user.is_authenticated:
            # Get user's roles
            user_roles = request.user.role.all().values_list('id', flat=True)

            # Allow update only if user has role 3
            if 3 in user_roles:
                Leadnote.objects.filter(
                    deleted_at__isnull=True, 
                    is_read=0, 
                    assigned_to=request.user,
                    reminder_date__in=[today, None]  # Update only notes assigned to the user
                ).update(is_read=1)
                return JsonResponse({'status': 'success', 'message': 'Notes marked as read'})

            return JsonResponse({'status': 'error', 'message': 'Permission denied'}, status=403)

        return JsonResponse({'status': 'error', 'message': 'Unauthorized'}, status=403)
def add_lead_attachment(request, id):
    if request.method == 'POST':
        lead = get_object_or_404(Lead, id=id)
        for file in request.FILES.getlist('image_attachments'):
            LeadAttachmentPhotos.objects.create(
                lead=lead,
                attachment=file,
                created_by=request.user,
                updated_by=request.user
            )
        for file in request.FILES.getlist('file_attachments'):
            LeadAttachmentFiles.objects.create(
                lead=lead,
                attachment=file,
                created_by=request.user,
                updated_by=request.user
            )
    return redirect('leads:list')
def lead_attachments_view(request, lead_id):
    attachments = LeadAttachmentPhotos.objects.filter(lead_id=lead_id, soft_deleted=False)
    attachmentfiless = LeadAttachmentFiles.objects.filter(lead_id=lead_id, soft_deleted=False)
    return render(request, 'pages/leads/view_attachment.html', {'attachments': attachments,'attachmentfiless' : attachmentfiless, 'lead_id': lead_id})


def export_leads_csv(request):
    response = HttpResponse(content_type='text/csv')
    response['Content-Disposition'] = 'attachment; filename="customers.csv"'

    writer = csv.writer(response)
    writer.writerow(['ID', 'Company Name','Customer Name ', 'Email','Work Phone','Mobile','ABN','Address','Business Type','Lead Source','Interasted In Products'])

    for lead in Lead.objects.all():
        # dd(customer)
        business_type = lead.get_business_type_display()
        lead_source = lead.get_lead_source_display()
        products = ", ".join(lead.products) if lead.products else ""
        product_names = Product.objects.filter(id__in=lead.products).values_list('product_name', flat=True)
        products_str = ", ".join(product_names)
        address=lead.city+', '+lead.street+', '+lead.state+', '+lead.street+' '+lead.post_code+' '+lead.country;
        writer.writerow([lead.id,lead.company_name, f"{lead.first_name} {lead.last_name}", lead.email,lead.work_phone,lead.mobile,lead.abn,address,business_type,lead_source,products_str])
        
               
    return response
def process_note_action(request, note_id):
    if request.method == "POST":
        action_type = request.POST.get("action_type")
        note = Leadnote.objects.get(id=note_id)

        if action_type == "mark_read":
            note.is_read = True
            note.updated_by = request.user
            note.save()
            messages.success(request, "Note marked as read.")

        elif action_type == "update_log":
            new_log = request.POST.get("log_note")
            note.is_read = True
            note.updated_by = request.user
            note.save()
            new_date = request.POST.get("reminder_date") or None
            Leadnote.objects.create(
                lead=note.lead,
                groupid=request.POST.get("groupid"),
                note=new_log,
                reminder_date = new_date,
                created_by = request.user,
                assigned_to=note.assigned_to,
                created_at=now(),
            )
            messages.success(request, "New log added successfully.")

        elif action_type == "reschedule":
            new_date = request.POST.get("reschedule_date") or None
            note.reminder_date = new_date
            note.updated_by = request.user
            note.save()
            messages.success(request, "Reminder date updated.")

        return redirect("leads:note_list")  # Adjust this URL to match your project

    return JsonResponse({"status": "error", "message": "Invalid request"}, status=400)
def add_customer_note(request, id):
    lead = get_object_or_404(Lead, id=id)
    meeting_invitation = 0
    meet_link = None
    meeting_time = None
    if 'meeting_invitation' in request.POST:
        meeting_invitation = 1
        meeting_time = request.POST.get('meeting_time')
    meet_link = request.POST.get('meet_link')
    if request.method == "POST":
        note = request.POST.get("note")
        userid = request.POST.get("userid") or None
        reminder_date = request.POST.get("reminder_date") or None  # Optional field
        if not userid == None:
            assigned_user = get_object_or_404(User, id=userid)
        else:
            assigned_user=None
        
        last_group = Leadnote.objects.order_by('-groupid').first()
        next_group_id = (last_group.groupid + 1) if last_group else 1
        # dd(request.POST.get('meeting_time'))
        Leadnote.objects.create(
            lead=lead,
            note=note,
            reminder_date=reminder_date,
            meeting_time=meeting_time,
            created_by = request.user,
            assigned_to=assigned_user,
            groupid=next_group_id,
            meeting_invitation=meeting_invitation,
            meet_link=meet_link
        )

        messages.success(request, "Note added successfully!")
        return redirect('leads:list')  # Adjust to your actual view

    return redirect('leads:list')
@login_required
def note_customer(request, id):
    lead = get_object_or_404(Lead, pk=id)
   
    context={'leads': lead}
    # dd(invoice.get_history)
    # dd( customer.note_history)
    note = lead.note_history
    # dd(note)
    # excluded_role_ids = [1,4,5]
    # users = User.objects.filter(deleted_at__isnull=True,is_superuser=0).exclude(role__id__in=excluded_role_ids)
    users = User.objects.filter( deleted_at__isnull=True, is_superuser=0, role__id=2 ).distinct()
    
    return render(request, 'pages/leads/note.html', {'users':users,'notes':note,'lead':lead})
@login_required
def note_list_customer(request):
    today = localdate()  
    user = request.user 
    # excluded_role_ids = [1,4,5]  #
    # users = User.objects.filter(deleted_at__isnull=True, is_superuser=0).exclude(role__id__in=excluded_role_ids)
    users = User.objects.filter( deleted_at__isnull=True, is_superuser=0, role__id=2 ).distinct()

    # note = Leadnote.objects.filter(deleted_at__isnull=True)
   
    # users = User.objects.filter(deleted_at__isnull=True,is_superuser=0).exclude(role__id__in=excluded_role_ids)
    # Check user's role
    user_roles = user.role.all().values_list('id', flat=True)  # Get role IDs

    # Check role-based filtering
    if 1 in user_roles:
        # Role 1: Show all customer notes
        # notes = Leadnote.objects.filter(deleted_at__isnull=True, reminder_date__in=[today, None]).order_by('-created_at')
        latest_notes = (
            Leadnote.objects.filter(
                #reminder_date__in=[today, None],
                reminder_date__isnull=False,
                reminder_date__lte=today,
                is_read=0,
                deleted_at__isnull=True
            )
            .values('groupid')  # Group by groupid
            .annotate(lat_created_at=Max('created_at'))  # Get latest created_at per group
        )

        # Fetch actual notes matching the latest created_at per groupid
        notes =  Leadnote.objects.filter(
            # reminder_date__in=[today, None],
            reminder_date__isnull=False,
            reminder_date__lte=today,
            is_read=0,
            deleted_at__isnull=True
        ).filter(
            Q(groupid__in=[note['groupid'] for note in latest_notes]),
            Q(created_at__in=[note['lat_created_at'] for note in latest_notes])
        ).order_by('-reminder_date') 
    elif 2 in user_roles:
        # Role 3: Show only notes assigned to the logged-in user
        # notes = Leadnote.objects.filter(deleted_at__isnull=True, assigned_to__id=user.id, reminder_date__in=[today, None]).order_by('-created_at')
        latest_notes = (
            Leadnote.objects.filter(
                # reminder_date__in=[today, None],
                reminder_date__isnull=False,
                reminder_date__lte=today,
                is_read=0,
                assigned_to__id=user.id,
                deleted_at__isnull=True
            )
            .values('groupid')  # Group by groupid
            .annotate(lat_created_at=Max('created_at'))  # Get latest created_at per group
        )

        # Fetch actual notes matching the latest created_at per groupid
        notes =  Leadnote.objects.filter(
            # reminder_date__in=[today, None],
            reminder_date__isnull=False,
            reminder_date__lte=today,
            is_read=0,
            assigned_to__id=user.id,
            deleted_at__isnull=True
        ).filter(
            Q(groupid__in=[note['groupid'] for note in latest_notes]),
            Q(created_at__in=[note['lat_created_at'] for note in latest_notes])
        ).order_by('-reminder_date') 
    else:
        # Other roles: No access
        notes = Leadnote.objects.none()
    if request.user.is_authenticated:
        user_roles = list(request.user.role.all().values_list('id', flat=True))
    else:
        user_roles = []
    # dd(user_roles)
    return render(request, 'pages/notification/lead_note_list.html', {'users':users,'notes':notes,'user_roles':user_roles})
@login_required    
def update_customer_note(request,id):
    CustNote=Leadnote.objects.get(id=id)
    if request.method == 'POST':
        reminder_date = request.POST.get("reminder_date") or None  # Optional field
        meeting_time = None
        meeting_invitation= None
        if 'meeting_invitation' in request.POST:
            meeting_invitation = 1
            meeting_time = request.POST.get('meeting_time')
        userid = request.POST.get("userid") or None
        if not userid == None:
            assigned_user = get_object_or_404(User, id=userid)
        else:
            assigned_user=None
        
        CustNote.note=request.POST.get("note")
        # dd(customer.user)
        CustNote.reminder_date=reminder_date
        CustNote.assigned_to=assigned_user
        CustNote.meeting_invitation=meeting_invitation
        CustNote.meeting_time=meeting_time
        CustNote.updated_by = request.user
        CustNote.save()
    messages.success(request, "Note updated successfully!")
    return redirect(reverse('leads:note_customer', args=[CustNote.lead.id]))
@login_required
def note_delete(request, id):
    # customer = CustNote.objects.get(id=id)
    # customer.deleted_by = request.user  
    # customer.delete()
    # id=2
    note = get_object_or_404(Customernote, id=id)
    note.deleted_by = request.user 
    note.soft_delete()
    # note.delete()
    messages.success(request, 'Customer Note Deleted Successfully.')
    return redirect(reverse('leads:note_customer', args=[note.customer.id])) 

def myhistory(row):
    if not row.model_name == 'Quotation' and not row.model_name == 'SerialNumber'  and not row.model_name == 'Invoice':
            result = []
            old = []
            newarr = []
            activity={}
            activity['model_name']=row.model_name
            activity['timestamp']=row.timestamp
            activity['activity_by'] = str(row.user.userinfo.get_name) if row.user and row.user.userinfo is not None else 'Admin'
            if row.action == 'Updated':
                a = json.dumps(row.new_data[0]['fields'])
                b = json.dumps( row.old_data[0]['fields'])
                a = json.loads(a)
                b = json.loads(b)
                for key in a:
                    if key != 'is_primary':
                        activity['action']='Updated'
                        replace=key

                        if key == 'primary_emails':
                            replace="Primary Email"
                            

                        if key not in b:
                            result.append(f'{dict({replace: a[key]})} -> {"replace deleted"}')
                            activity['log_activity']=f'{dict({replace: a[key]})} -> {"replace deleted"}'
                            # activity['log_activity']=f'Updated <b>{dict({key: b[key]})} </b> <b>{" Added"} </b>'

                        if key in a and key in b and a[key] != b[key] and a[key] != None and  b[key] != None and a[key] != '' and b[key] != ''  :


                            result.append(f'{dict({replace: a[key]})} -> {dict({replace: b[key]})}')
                            if not ( key == 'updated_at' or key == 'updated_at' or key == 'updated_by' or key == 'deleted_at'):
                                old.append(f'Updated {replace} From {a[key]} to {b[key]}')
                                activity['log_activity']=f'<b>{replace} </b> From   <b>{b[key]} </b> To  <b>{a[key]} </b>'
            if row.action == 'Deleted':
                result.append(f'Deleted')
                activity['log_activity']='Deleted'
                activity['action']='Deleted'
            if row.action == 'Created':
                result.append(f'Created')
                activity['log_activity']='Created'
                activity['action']='Created'
            return activity  
@user_passes_test(lambda u: is_admin(u) or is_superuser(u))
@login_required
def activity_customer(request, id):
    customer = get_object_or_404(Customer, pk=id)
   
    context={'customers': customer}
    # dd(invoice.get_history)
    
    history = customer.get_history
    t1=[]
    if history:
        
        for cus in history:
           
            t=myhistory(cus)

            if t is not None:
               t1.append(t)
    counter = 1

    for cust in t1:
        if 'log_activity' in cust and cust['log_activity'] is not None and cust['log_activity'] != ''  :
            cust['row_number'] = counter
            counter += 1
    return render(request, 'pages/leads/activity.html', {'t1':t1,'counter':counter})




@login_required
def generate_map_url(lead):
    address = f"{lead.street}, {lead.city}, {lead.state} {lead.post_code}, {lead.country}"
    encoded_address = urllib.parse.quote(address)
    return f"https://www.google.com/maps/search/?api=1&query={encoded_address}"
@login_required
def list_customer(request):
    env_vars = os.environ
    for key, value in env_vars.items():
        print(f"{key}: {value}")
    customer_id = request.GET.get('customer_id')
    email = request.GET.get('email')
    phone = request.GET.get('phone')
    status = request.GET.get('status')
    lead_source = request.GET.get('lead_source')
    
    if is_admin(request.user):
        customer=Lead.objects.filter(deleted_at__isnull=True)
    elif  '2' in request.user.get_role :
        assigned_to = User.objects.get(id=request.user.id)
        customer = Lead.objects.filter(assigned_to=assigned_to, deleted_by__isnull=True)
        
    # dd(request.user.get_role)
    # customer=Lead.objects.filter(deleted_at__isnull=True)
    # customer = Customer_Info.objects.filter(customer__in=customer_data, is_primary=True)

    
    if customer_id:
        customer = Lead.objects.filter(Q(id=customer_id) )
              
    if email:
        email = request.GET.get('email').strip()
        customer = customer.filter(email__icontains=email)

    if phone:
        phone = request.GET.get('phone').strip()
        customer = customer.filter(
        Q(work_phone__icontains=phone) | Q(mobile__icontains=phone)
        )
    if lead_source:
        customer = customer.filter(lead_source=lead_source)
    if status:
        customer = customer.filter(is_active=status)
        
    business_type = request.GET.get('business_type')
    if business_type:
        customer = customer.filter(business_type=business_type)

    # 4. Filter by selected products (many-to-many or foreign key)
    product_ids = request.GET.get('products')
    if product_ids:
        product_ids = [int(pid.strip()) for pid in product_ids.split(',') if pid.strip().isdigit()]
        customer = customer.filter(products__contains=product_ids)

    # 5. Filter by sales user
    userid = request.GET.get('userid')
    if userid:
        customer = customer.filter(assigned_to_id=userid)  # adjust field name accordingly
    address = request.GET.get('address')
    if address:
        address = address.strip()
        customer = customer.filter(
            Q(state__icontains=address) |
            Q(city__icontains=address) |
            Q(street__icontains=address) |
            Q(country__icontains=address) |
            Q(post_code__icontains=address)
        )
    total_records = customer.count()
    show_pagination = total_records > settings.PAGE_RECORDS
    if show_pagination:     
        page = request.GET.get('page', 1)
        paginator = Paginator(customer, settings.PAGE_RECORDS)  # Show 10 customers per page
        try:
            customer = paginator.page(page)
        except PageNotAnInteger:
            customer = paginator.page(1)
        except EmptyPage:
            customer = paginator.page(paginator.num_pages)
    # excluded_role_ids = [1,4,5]  #
    # # dd(settings.PAGE_RECORDS)
    # users = User.objects.filter(deleted_at__isnull=True,is_superuser=0).exclude(role__id__in=excluded_role_ids)
    users = User.objects.filter( deleted_at__isnull=True, is_superuser=0, role__id=2 ).distinct()
    if is_admin(request.user):
        leads = Lead.objects.filter(deleted_at__isnull=True)
    elif  '2' in request.user.get_role :
        assigned_to = User.objects.get(id=request.user.id)
        leads = Lead.objects.filter(deleted_at__isnull=True,assigned_to=assigned_to)
    allproducts = Product.objects.filter(deleted_at__isnull=True )
    return render(request,'pages/leads/list.html', {'users':users,'customers': customer,'cust':leads,'allproducts':allproducts})


@login_required
def create_customer(request):
    allproducts = Product.objects.filter(deleted_at__isnull=True )
    # excluded_role_ids = [1,4,5]  #
    # users = User.objects.filter(deleted_at__isnull=True,is_superuser=0).exclude(role__id__in=excluded_role_ids)
    users = User.objects.filter( deleted_at__isnull=True, is_superuser=0, role__id=2 ).distinct()
    return render(request,'pages/leads/create.html', {'allproducts': allproducts,'users':users})
def convert_to_customer(request,id):
    lead = Lead.objects.get(id=id)
    return render(request,'pages/customer/leadConvertToCustomer.html', {'lead': lead})
@login_required
def post_lead(request):
    # dd(request.POST)
    context={}
    if request.method == 'POST':
        # dd(request.POST)
        form = request.POST
        company_name = request.POST.get('company_name', '').strip()
        first_name = request.POST.get('first_name', '').strip()

        if not company_name and not first_name:
            messages.error(request, "Either Company Name or First Name is required.")
            context['form'] = request.POST
            allproducts = Product.objects.filter(deleted_at__isnull=True )
            return render(request, 'pages/leads/create.html', {'context':context,'allproducts': allproducts})
            # return JsonResponse(context, status=400)

            # Continue processing the valid input...
            # e.g., save to DB or perform further checks
            
        # is_active= request.POST.get('is_active')
       
        # if is_active is None:
        #   is_active = False
        # else:
        is_active = True
        # abn=request.POST.get('abn'),
        # if abn  and len(abn ) == 11:
        #     abnres = f"{abn[:2]} {abn[2:5]} {abn[5:8]} {abn[8:]}"
        # else:
        #     abnres=abn
        userid = request.POST.get("userid") or None
        if not userid == None:
            assigned_user = get_object_or_404(User, id=userid)
        else:
            assigned_user=request.user
        if request.POST.get('business_type') == '':
            business_type = None
        else:
            business_type=request.POST.get('business_type')
        if request.POST.get('lead_source') == '':
            lead_source = None
        else:
            lead_source=request.POST.get('lead_source')
        lead = Lead.objects.create(
             is_individual= 1,
             company_name= request.POST.get('company_name'),
            first_name = request.POST.get('first_name'),
            last_name = request.POST.get('last_name'),
            email = request.POST.get('email'),
            work_phone = request.POST.get('phone1'),
            mobile = request.POST.get('mobile'),
            is_active=is_active,
            abn=request.POST.get('abn'),
            lead_source=lead_source,
            business_type=business_type,
            products= request.POST.getlist('products[]'),
            street=request.POST.get('street'),
            city=request.POST.get('city'),
            state=request.POST.get('state'),
            post_code=request.POST.get('post_code'),
            country=request.POST.get('country'),
            # assigned_to=request.user,
            assigned_to=assigned_user,
            geolocation='' #request.POST.get('geolocation'),
        )
        # addressurl=generate_map_url(lead)
        # lead.geolocation=addressurl
        lead.save()
        messages.success(request, "Lead Added successfully!") 
        return redirect('leads:list')        
    else:      
        context['form'] = request.POST
        allproducts = Product.objects.filter(deleted_at__isnull=True )
        return render(request, 'pages/leads/create.html', {'context':context,'allproducts': allproducts})


@login_required    
def edit_customer(request,id):
    lead = Lead.objects.get(id=id)
    users = User.objects.filter( deleted_at__isnull=True, is_superuser=0, role__id=2 ).distinct()
    selected_product_ids = []
    if lead.products:
        selected_product_ids = [int(pid) for pid in lead.products]
   
    if request.method == 'POST':
        # dd(request.POST)
        form = request.POST
        company_name = request.POST.get('company_name', '').strip()
        first_name = request.POST.get('first_name', '').strip()

        if not company_name and not first_name:
            messages.error(request, "Either Company Name or First Name is required.")
            allproducts = Product.objects.filter(deleted_at__isnull=True )
            return render(request,'pages/leads/edit.html',{'lead': lead,'allproducts':allproducts,'selected_product_ids':selected_product_ids})
        if request.POST.get('business_type') == '':
            business_type = None
        else:
            business_type=request.POST.get('business_type')
        if request.POST.get('lead_source') == '':
            lead_source = None
        else:
            lead_source=request.POST.get('lead_source')
        userid = request.POST.get("userid")
        if userid:
            try:
                # Strip any stray commas or periods, then convert to int
                user_id_clean = int(str(userid).strip().replace(',', '').replace('.', ''))
                assigned_user = get_object_or_404(User, id=user_id_clean)
            except (ValueError, TypeError):
                assigned_user = None  # or handle invalid input
        else:
            assigned_user = request.user
        # dd(user_id_clean)
        is_active = True
        lead.is_individual= 1
        lead.company_name= request.POST.get('company_name')
        lead.first_name = request.POST.get('first_name')
        lead.last_name = request.POST.get('last_name')
        lead.email = request.POST.get('email')
        lead.work_phone = request.POST.get('phone1')
        lead.mobile = request.POST.get('mobile')
        lead.is_active=is_active
        lead.abn=request.POST.get('abn')
        lead.lead_source=lead_source
        lead.business_type=business_type
        lead.assigned_to_id=assigned_user
        lead.products= request.POST.getlist('products[]')
        lead.street=request.POST.get('street')
        lead.city=request.POST.get('city')
        lead.state=request.POST.get('state')
        lead.post_code=request.POST.get('post_code')
        lead.country=request.POST.get('country')
        lead.geolocation='' #request.POST.get('geolocation'),

        lead.updated_by = request.user
        lead.save()    
       
        messages.success(request, 'Lead Updated Successfully.')
        return redirect('leads:list')
    allproducts = Product.objects.filter(deleted_at__isnull=True )
    return render(request,'pages/leads/edit.html',{'lead': lead,'allproducts':allproducts,'selected_product_ids':selected_product_ids,'users':users})
    
def show_customer(request,id):
    lead = Lead.objects.get(id=id)
    users = User.objects.filter( deleted_at__isnull=True, is_superuser=0, role__id=2 ).distinct()
    selected_product_ids = []
    if lead.products:
        selected_product_ids = [int(pid) for pid in lead.products]
    allproducts = Product.objects.filter(deleted_at__isnull=True )
    return render(request,'pages/leads/show.html',{'lead': lead,'allproducts':allproducts,'selected_product_ids':selected_product_ids,'users':users})
    
def add_quote(request, id):
    leadexist = Lead.objects.get(id=id)
    leads=Lead.objects.filter(deleted_at__isnull=True )
    return render(request,'pages/leads/add_quote.html',{'leadexist': leadexist,'leads':leads})
def add_lead_quote(request):
    if is_admin(request.user):
        leads = Lead.objects.filter(deleted_at__isnull=True)
    elif  '2' in request.user.get_role :
        assigned_to = User.objects.get(id=request.user.id)
        leads = Lead.objects.filter(deleted_at__isnull=True,assigned_to=assigned_to)
    return render(request,'pages/leads/add_quote.html',{'leads':leads})

def create_Lead_Quotation(request):
    id=request.POST.get('lead')
    lead= Lead.objects.get(id=id)
    attachment = request.FILES.get('attachment')
    existing_quotes_count = Lead_Quote.objects.filter(lead=lead).count()
    version_number = existing_quotes_count + 1
    leadquote = Lead_Quote.objects.create(
            lead=lead,
            mailstatus=0,
            version=version_number,
            created_by=request.user
        )
    if  attachment:
        filename = f'Excitech-Australia-Quotation-{leadquote.id}-{leadquote.version}.pdf'
        leadquote.attachment.save(filename, attachment)
        # leadquote.attachment.save(f'{leadquote.id}-attachment.pdf', attachment)
    messages.success(request, 'Lead Quote Added Successfully.')
    return redirect('leads:Lead_Quotation_list')
# def Lead_Quotation_list(request):
    
#     leads=Lead.objects.filter(deleted_at__isnull=True )
#     lead_id = request.GET.get('lead_id')
#     lead_quotes=Lead_Quote.objects.filter(deleted_at__isnull=True )
#     if lead_id:
#             lead_quotes = lead_quotes.objects.filter(Q(lead__id=lead_id) )
    
#     # dd(lead_quotes);
#     return render(request,'pages/leads/quote_list.html', {'leads':leads,'lead_quotes': lead_quotes})
@login_required
def Lead_Quotation_list(request):
    lead_id = request.GET.get('lead_id')
    
    if is_admin(request.user):
        leads = Lead.objects.filter(deleted_at__isnull=True)
    elif  '2' in request.user.get_role :
        assigned_to = User.objects.get(id=request.user.id)
        leads = Lead.objects.filter(deleted_at__isnull=True,assigned_to=assigned_to)
        
    if is_admin(request.user):
        lead_quotes = Lead_Quote.objects.filter(deleted_at__isnull=True)
    elif  '2' in request.user.get_role :
        assigned_to = User.objects.get(id=request.user.id)
        lead_quotes = Lead_Quote.objects.filter(deleted_at__isnull=True,lead__assigned_to=assigned_to)
        # customer = Lead.objects.filter(assigned_to=assigned_to, deleted_by__isnull=True)
    

    if lead_id:
        lead_quotes = lead_quotes.filter(Q(lead__id=lead_id))
    

    return render(request, 'pages/leads/quote_list.html', {
        'leads': leads,
        'lead_quotes': lead_quotes
    })
@login_required
def Lead_Quotation_list_by_lead(request,lead_id):
    
    if is_admin(request.user):
        leads = Lead.objects.filter(deleted_at__isnull=True,id=lead_id)
    elif  '2' in request.user.get_role :
        assigned_to = User.objects.get(id=request.user.id)
        leads = Lead.objects.filter(deleted_at__isnull=True,assigned_to=assigned_to,id=lead_id)
        
    if is_admin(request.user):
        lead_quotes = Lead_Quote.objects.filter(deleted_at__isnull=True,lead_id=lead_id)
    elif  '2' in request.user.get_role :
        assigned_to = User.objects.get(id=request.user.id)
        lead_quotes = Lead_Quote.objects.filter(deleted_at__isnull=True,lead__assigned_to=assigned_to,lead_id=lead_id)
        # customer = Lead.objects.filter(assigned_to=assigned_to, deleted_by__isnull=True)
    

    # if lead_id:
    #     lead_quotes = lead_quotes.filter(Q(lead__id=lead_id))

    return render(request, 'pages/leads/quote_list.html', {
        'leads': leads,
        'lead_quotes': lead_quotes
    })
def edit_quote(request):
    dd('edit_quote')
@login_required
def delete_customer(request, id):
    customer = Lead.objects.get(id=id)
    customer.deleted_by = request.user  
    customer.delete()
    
    
    messages.success(request, 'Lead Deleted Successfully.')
    return redirect('leads:list')
def send_lead_note_email(request, lead_id, note_id):
    lead = get_object_or_404(Lead, id=lead_id)
    note = get_object_or_404(Leadnote, id=note_id, lead=lead)

    if not lead.email:
        messages.error(request, 'Lead has no email address.')
        return redirect(request.META.get('HTTP_REFERER', '/'))

    subject = f'EXCITECH Australia - Meeting Scheduled for {lead.first_name } {lead.last_name}'
    context = {
        'lead': lead,
        'note': note,
    }
    message = render_to_string('pages/leads/lead_note_email.html', context)
    from_email = settings.FROM_EMAIL
    try:
        email = EmailMessage(subject, message, from_email, [lead.email])
        email.content_subtype = 'html'  # To send HTML content
        email.send()
        note.mail_status=1
        note.save()
        messages.success(request, 'Note email sent successfully.')
    except Exception as e:
        messages.error(request, f'Failed to send email: {e}')

    return redirect(request.META.get('HTTP_REFERER', '/')) 
def send_quotation_mail_lead(request,id,):
    leadquote = get_object_or_404(Lead_Quote, id=id)
    # quotationitem = QuotationItem.objects.filter(quotation=quotation)
    lead = Lead.objects.get(id=leadquote.lead.id)
    # quotation_detail_url = request.build_absolute_uri(reverse('quotation:view_quotation_detail', args=[quotation.id]))
    subject = f'EXCITECH Australia - Quote Confirmation Required for Quote ID {leadquote.id}'
    confirm=True
    template_data = {'quotation': leadquote}
    message = render_to_string('pages/leads/quote_email_temp.html', template_data)

    # message += "Please find attached Quote."
    
    from_email = settings.FROM_EMAIL
 
    recipient_email = lead.email 
   
    email = EmailMessage(subject, message, from_email, [recipient_email])
    
    if email:
       pdf_file_path = leadquote.attachment.path
       email.attach_file(pdf_file_path, 'application/pdf')
       email.content_subtype = 'html'
       email.send()
       
    #   get_registration_token = get_object_or_404(FCMDevice,user_id=customer.user.id)
    #   sendPush('Quote Confirmation Notification',f'EXCITECH Australia - Quote Confirmation Required for Quote ID {quotation.id}',[get_registration_token.registration_id])
       leadquote.mailstatus=1
       
       leadquote.save()
       
       print("------------------")
       print("send mail",email)
       messages.success(request, 'Mail Sent Successfully.')
       return redirect(request.META.get('HTTP_REFERER', '/'))
    else:
        messages.error(request, 'Failed To Send Mail.')
        return redirect('leads:Lead_Quotation_list')