from django.db.models import Q
import json
import uuid
from openai import OpenAI
import requests
from twilio.rest import Client
from django.conf import settings
from django.utils import timezone
from django.utils.html import escape
from django.utils.translation import gettext_lazy as _
from django.urls import path, reverse
from django.utils.safestring import mark_safe
from django.contrib import messages
from .models import InventoryLog, ProductImage, ProductViewLog, SiteVisit, Ticket, TicketReply
from shop.model_translator import get_product_translated_data
from django.core.mail import EmailMessage
from django.views.decorators.csrf import csrf_exempt
from django.template.loader import render_to_string
from django.contrib.auth.decorators import login_required
from django.contrib.auth.decorators import user_passes_test
from django.http import HttpResponse, StreamingHttpResponse, JsonResponse
from django.shortcuts import render, redirect, get_object_or_404
from shop.forms import ProductCreateForm, ProductImageForm, OfferRequestForm
from shop.utils import send_customer_reply_notification, send_staff_customer_reply_notification, send_offer_submission_notification
from .models import Product, Category, Cart, CartItem, Order, ChatMessage, Review, Wishlist, PaymentLog, OfferRequest
from decimal import Decimal

from django.contrib.messages import get_messages
from django.db.models.functions import TruncMonth, TruncYear
from django.db.models import Sum

def privacy_policy(request):
    return render(request, 'privacy_policy.html')

def terms_of_service(request):
    return render(request, 'terms_of_service.html')

def cookie_policy(request):
    return render(request, 'cookie_policy.html')


def get_or_create_cart(user):
    cart, created = Cart.objects.get_or_create(user=user)
    return cart


def get_session_cart(request):
    """Get cart from session"""
    return request.session.get('cart', {})


def save_session_cart(request, cart):
    """Save cart to session"""
    request.session['cart'] = cart
    request.session.modified = True


def add_product_to_session_cart(request, product):
    """Add a product to the session cart"""
    cart = get_session_cart(request)
    pid = str(product.id)
    
    if pid in cart:
        cart[pid]['quantity'] += 1
    else:
        discount = product.get_active_discount()
        if discount:
            discounted_price = discount.calculate_discounted_price(product.price)
            original_price = product.price
        else:
            discounted_price = product.price
            original_price = product.price
        
        cart[pid] = {
            'name': product.name,
            'price': float(discounted_price),
            'original_price': float(original_price),
            'quantity': 1,
            'has_discount': discount is not None,
            'discount_amount': float(discount.calculate_discount_amount(product.price)) if discount else 0,
        }
    
    save_session_cart(request, cart)
    return cart


def about(request):
    return render(request, 'about.html')


def contact(request):
    return render(request, 'contact.html')


def faq(request):
    return render(request, 'faq.html')


def live_visitors_count(request):
    today = timezone.now().date()
    visitors = SiteVisit.objects.filter(date=today).aggregate(total=Sum('daily_visits'))['total'] or 0
    return JsonResponse({'daily_visitors': visitors})


def help(request):
    return render(request, 'help.html')

def home(request):
    featured = Product.objects.all()[:8]
    categories = Category.objects.all()
    translated_featured = [get_product_translated_data(p) for p in featured]

    total_reviews = Review.objects.count()
    if total_reviews:
        satisfied_reviews = Review.objects.filter(rating__gte=4).count()
        satisfaction_rate = int(round((satisfied_reviews / total_reviews) * 100))
    else:
        satisfaction_rate = 95

    return render(request, 'shop/index.html', {
        'featured': featured,
        'translated_featured': translated_featured,
        'categories': categories,
        'satisfaction_rate': satisfaction_rate,
    })


def product_list(request):
    products = Product.objects.all()
    categories = Category.objects.all()
    translated_products = [get_product_translated_data(p) for p in products]

    q = request.GET.get('q')
    category_slug = request.GET.get('category')

    if q:
        products = products.filter(name__icontains=q)

    if category_slug:
        products = products.filter(category__slug=category_slug)
        # Filter categories to show only the selected category
        categories = categories.filter(slug=category_slug)

    # ✅ Detect HTMX request
    if request.headers.get('HX-Request'):
        return render(request, 'shop/partials/product_grid.html', {
            'products': products,
            'selected_category_slug': category_slug
        })

    # ✅ Normal request
    return render(request, 'shop/product_list.html', {
        'products': products,
        'translated_products': translated_products,
        'categories': categories,
        'selected_category_slug': category_slug
    })
    


def product_detail(request, slug):
    product = get_object_or_404(Product, slug=slug)
    offer_form = OfferRequestForm() if product.allow_customer_offer else None

    if not request.session.session_key:
        request.session.save()

    viewed_products = request.session.get('viewed_products', [])
    if product.id not in viewed_products:
        product.view_count = product.view_count + 1
        product.save(update_fields=['view_count'])
        viewed_products.append(product.id)
        request.session['viewed_products'] = viewed_products

    product.track_view(
        user=request.user if request.user.is_authenticated else None,
        session_key=request.session.session_key,
        ip_address=request.META.get('REMOTE_ADDR'),
        referer=request.META.get('HTTP_REFERER'),
        user_agent=request.META.get('HTTP_USER_AGENT')
    )

    translated_product = get_product_translated_data(product)

    return render(request, 'shop/product_detail.html', {
        'product': product,
        'translated_product': translated_product,
        'offer_form': offer_form,
    })


@login_required
def make_offer(request, slug):
    product = get_object_or_404(Product, slug=slug)

    if not product.allow_customer_offer:
        messages.error(request, 'This product is not open for customer offers.')
        return redirect('shop:product_detail', slug=slug)

    if request.method == 'POST':
        form = OfferRequestForm(request.POST)
        if form.is_valid():
            offered_price = form.cleaned_data['offered_price']
            if product.min_offer_price and offered_price < product.min_offer_price:
                form.add_error('offered_price', f'Offers must be at least {product.min_offer_price:.2f}.')
            else:
                offer = OfferRequest.objects.create(
                    product=product,
                    user=request.user,
                    offered_price=offered_price,
                    message=form.cleaned_data.get('message', '')
                )
                send_offer_submission_notification(offer)
                
                # Automatically add product to cart
                add_product_to_session_cart(request, product)
                
                messages.success(request, 'Your offer has been submitted. The product has been added to your cart. We will review it and contact you soon.')
                return redirect('shop:product_detail', slug=product.slug)
    else:
        form = OfferRequestForm()

    return render(request, 'shop/product_detail.html', {
        'product': product,
        'offer_form': form,
    })


@user_passes_test(lambda u: u.is_staff)
def manage_dashboard(request):
    orders = Order.objects.all().order_by('-created_at')[:12]
    transactions = PaymentLog.objects.select_related('order').all().order_by('-created_at')[:12]
    tickets = Ticket.objects.all().order_by('-created_at')[:12]
    offers = OfferRequest.objects.select_related('product', 'user').order_by('-created_at')[:12]
    pending_offer_count = OfferRequest.objects.filter(status='Pending').count()
    accepted_offer_count = OfferRequest.objects.filter(status='Accepted').count()
    declined_offer_count = OfferRequest.objects.filter(status='Declined').count()

    return render(request, 'manage/dashboard.html', {
        'orders': orders,
        'transactions': transactions,
        'tickets': tickets,
        'offers': offers,
        'pending_offer_count': pending_offer_count,
        'accepted_offer_count': accepted_offer_count,
        'declined_offer_count': declined_offer_count,
    })


@login_required
def create_product(request):
    image_forms = [ProductImageForm(prefix=f'image_{i}') for i in range(5)]

    if request.method == 'POST':
        form = ProductCreateForm(request.POST, request.FILES)

        if form.is_valid():
            name = form.cleaned_data['name'].strip()

            # Check for duplicate product name (case-insensitive)
            if Product.objects.filter(name__iexact=name).exists():
                messages.error(request, f'A product with the name "{name}" already exists. Please use a different name.')
            else:
                # Handle new category creation
                new_category_name = form.cleaned_data.get('new_category')
                if new_category_name:
                    category, created = Category.objects.get_or_create(name=new_category_name.strip())
                    product = form.save(commit=False)
                    product.category = category
                else:
                    product = form.save()

                product.save()

                # Process uploaded image files
                for i in range(5):
                    image_field = request.FILES.get(f'image_{i}-image')
                    if image_field:
                        alt_text = request.POST.get(f'image_{i}-alt_text', '')
                        is_primary = request.POST.get(f'image_{i}-is_primary') == 'on'
                        ProductImage.objects.create(
                            product=product,
                            image=image_field,
                            alt_text=alt_text,
                            is_primary=is_primary
                        )

                # Success message + redirect
                messages.success(request, f'✅ Product "{product.name}" has been created successfully!')
                return redirect('shop:product_detail', slug=product.slug)
        else:
            messages.error(request, 'There was a problem creating the product. Please fix the errors below.')
    else:
        form = ProductCreateForm()

    return render(request, 'shop/create_product.html', {
        'form': form,
        'image_forms': image_forms,
    })
        

@login_required
def product_update(request, slug):
    product = get_object_or_404(Product, slug=slug)

    if request.method == 'POST':
        form = ProductCreateForm(request.POST, request.FILES, instance=product)
        
        if form.is_valid():
            name = form.cleaned_data['name'].strip()

            # Check for duplicate name (excluding current product)
            if Product.objects.filter(name__iexact=name).exclude(pk=product.pk).exists():
                messages.error(request, f'A product with the name "{name}" already exists.')
            else:
                # Handle new category creation
                new_category_name = form.cleaned_data.get('new_category')
                if new_category_name:
                    category, _ = Category.objects.get_or_create(name=new_category_name.strip())
                    product = form.save(commit=False)
                    product.category = category
                else:
                    product = form.save()

                product.save()

                # Handle new image uploads
                for i in range(5):  # up to 5 new images
                    image_field = request.FILES.get(f'image_{i}-image')
                    if image_field:
                        alt_text = request.POST.get(f'image_{i}-alt_text', '')
                        is_primary = request.POST.get(f'image_{i}-is_primary') == 'on'
                        ProductImage.objects.create(
                            product=product,
                            image=image_field,
                            alt_text=alt_text,
                            is_primary=is_primary
                        )

                messages.success(request, f'✅ Product "{product.name}" has been updated successfully!')
                return redirect('shop:product_detail', slug=product.slug)

    else:
        form = ProductCreateForm(instance=product)

    # Create empty image forms for new uploads
    image_forms = [ProductImageForm(prefix=f'image_{i}') for i in range(5)]

    return render(request, 'shop/update_product.html', {
        'form': form,
        'image_forms': image_forms,
        'product': product,           # Pass the product instance for existing images
    })
        

def get_or_create_session_cart(request):
    """Handle cart for both logged-in and guest users"""
    if request.user.is_authenticated:
        cart, created = Cart.objects.get_or_create(user=request.user)
        return cart
    else:
        # For guests: use session
        if 'guest_cart' not in request.session:
            request.session['guest_cart'] = {}  # {product_id: quantity}
        return request.session['guest_cart']


def merge_guest_cart_to_user(request, user):
    """Merge session cart into user's database cart after login"""
    if 'guest_cart' not in request.session:
        return

    guest_cart = request.session['guest_cart']
    user_cart = get_or_create_cart(user)

    for product_id_str, quantity in guest_cart.items():
        try:
            product = Product.objects.get(id=int(product_id_str))
            cart_item, created = CartItem.objects.get_or_create(
                cart=user_cart, product=product)
            if not created:
                cart_item.quantity += quantity
            else:
                cart_item.quantity = quantity
            cart_item.save()
        except Product.DoesNotExist:
            continue

    # Clear guest cart
    del request.session['guest_cart']
    request.session.modified = True


@login_required
def wishlist_view(request):
    items = Wishlist.objects.filter(
        user=request.user).select_related('product')
    return render(request, 'shop/wishlist.html', {'items': items})

def add_review(request, product_slug):
    product = get_object_or_404(Product, slug=product_slug)
    if request.method == 'POST' and request.user.is_authenticated:
        rating = int(request.POST.get('rating'))
        comment = request.POST.get('comment', '')
        Review.objects.update_or_create(
            product=product, user=request.user,
            defaults={'rating': rating, 'comment': comment}
        )
        return redirect('shop:product_detail', slug=product_slug)
    else:
        messages.error(
            request,
            mark_safe(
                f"You must be logged in to submit a review. "
                f"Please log in or create an account to share your feedback on "
                f"{escape(product.name)}.<br><br>"
                f"<a href='{reverse('account_login')}' class='btn btn-primary'>Click to Login</a>"
            )
        )

    return redirect('shop:product_detail', slug=product_slug)


# Multi-currency helper (simple demo rates)
# 1 USD ≈ 0.92 EUR, 1 USD ≈ 110 JPY
CURRENCY_RATES = {'USD': 1, 'EUR': 0.92, 'JPY': 110, 'GBP': 0.81}

def convert_price(price, to_currency='USD'):
    rate = CURRENCY_RATES.get(to_currency, 1)
    return round(price * rate, 2)


def get_ai_client():
    return OpenAI(
        base_url="https://api.x.ai/v1",
        api_key=settings.XAI_API_KEY
    )


def get_order_context(user):
    """Pull real order data for the current user"""
    recent_orders = Order.objects.filter(user=user).order_by('-created_at')[:5]
    if not recent_orders:
        return "You have no recent orders."

    context = "Here are the user's recent orders:\n"
    for order in recent_orders:
        items = ", ".join(
            [f"{item.quantity}x {item.product.name}" for item in order.items.all()])
        context += f"- Order #{order.id} | Status: {order.status} | Total: ${order.total} | Date: {order.created_at.strftime('%d %b %Y')} | Items: {items} | Address: {order.address[:80]}...\n"
    return context


def get_system_prompt(user, order_context):
    return f"""You are BanshiX AI Assistant, a helpful, friendly, and professional customer service agent for an e-commerce store.
    You specialize in:
    - Product information, recommendations, availability, and pricing across the Glob
    - Order status, tracking, payments (Flutterwave), shipping & delivery
    - Returns, refunds, wishlist, cart, and account help

    Current user context:
    {order_context}

    Always be polite, concise, solution-oriented, and use English where natural (but keep professional). 
    If the user asks about a specific order, use the provided data. Never make up tracking numbers.
    If you cannot help or the issue is complex, suggest talking to a live agent."""


@csrf_exempt  # Required for streaming endpoint with HTMX
def ai_chat_stream(request):
    if request.method == 'POST':
        user_message = request.POST.get('message', '').strip()
        if not user_message:
            return JsonResponse({'error': 'Message required'}, status=400)

        # Session handling
        if 'chat_session_id' not in request.session:
            request.session['chat_session_id'] = str(uuid.uuid4())
        session_id = request.session['chat_session_id']

        # Save user message
        ChatMessage.objects.create(
            user=request.user if request.user.is_authenticated else None,
            session_id=session_id,
            message=user_message,
            is_bot=False
        )

        # Build conversation history
        history = ChatMessage.objects.filter(
            session_id=session_id).order_by('created_at')
        order_context = get_order_context(
            request.user) if request.user.is_authenticated else "User is not logged in."

        messages = [
            {"role": "system", "content": get_system_prompt(
                request.user if request.user.is_authenticated else None, order_context)}
        ]
        for msg in history:
            role = "assistant" if msg.is_bot else "user"
            messages.append({"role": role, "content": msg.message})

        # Streaming response generator
        def stream_response():
            try:
                client = get_ai_client()
                stream = client.chat.completions.create(
                    model="grok-beta",   # or "grok-4.20-reasoning" if available in your plan
                    messages=messages,
                    temperature=0.7,
                    max_tokens=800,
                    stream=True
                )

                bot_reply = ""
                for chunk in stream:
                    if chunk.choices and chunk.choices[0].delta.content:
                        token = chunk.choices[0].delta.content
                        bot_reply += token
                        # Yield each token wrapped for HTMX partial update
                        yield f'<div class="bot-message mb-2">{token}</div>'

                # Save full bot response to DB after streaming
                ChatMessage.objects.create(
                    user=request.user if request.user.is_authenticated else None,
                    session_id=session_id,
                    message=bot_reply,
                    is_bot=True
                )

            except Exception as e:
                yield '<div class="text-danger">Sorry, I encountered an issue. Please try again or talk to a live agent.</div>'

        return StreamingHttpResponse(stream_response(), content_type='text/html')

    return JsonResponse({'error': 'Invalid request'}, status=400)


def clear_chat(request):
    session_id = request.session.get('chat_session_id')
    if session_id:
        ChatMessage.objects.filter(session_id=session_id).delete()
        del request.session['chat_session_id']
    return JsonResponse({'status': 'cleared'})


def send_escalation_notification(user, session_id, ticket):
    """Send email + WhatsApp with full context including phone"""

    profile = getattr(user, 'profile', None)
    customer_phone = profile.phone if profile and profile.phone else "Not provided"

    # Get last messages
    messages = ChatMessage.objects.filter(
        session_id=session_id).order_by('created_at')[:10]
    chat_history = "\n".join(
        [f"{'User' if not m.is_bot else 'AI'}: {m.message}" for m in messages])

    # Recent orders
    orders = Order.objects.filter(user=user).order_by('-created_at')[:3]
    order_summary = "\n".join(
        [f"Order #{o.id}: {o.status} - ${o.total}" for o in orders]) or "No recent orders"

    context = {
        'ticket_id': ticket.id,
        'user': user,
        'phone': customer_phone,
        'chat_history': chat_history,
        'order_summary': order_summary,
        'timestamp': timezone.now(),
    }

    # Email
    subject = f"🚨 Support Ticket #{ticket.id} - Escalation from {user.username}"
    html_message = render_to_string('shop/escalation_email.html', context)

    email = EmailMessage(subject, html_message, settings.DEFAULT_FROM_EMAIL, [
                         settings.SUPPORT_EMAIL])
    email.content_subtype = "html"
    email.send(fail_silently=False)

    # WhatsApp via Twilio
    try:
        client = Client(settings.TWILIO_ACCOUNT_SID,
                        settings.TWILIO_AUTH_TOKEN)
        whatsapp_body = f"""
        🚨 *New Support Ticket #{ticket.id}*

        Customer: {user.username}
        Phone: {customer_phone}
        Priority: {ticket.priority}
        Time: {timezone.now().strftime('%d %b %Y %H:%M')}

        Recent Orders:
        {order_summary}

        Chat Summary:
        {chat_history[:700]}...

        View full ticket in admin.
                """.strip()

        client.messages.create(
            body=whatsapp_body,
            from_=settings.TWILIO_WHATSAPP_NUMBER,
            to=settings.OWNER_WHATSAPP_NUMBER
        )
    except Exception as e:
        print(f"WhatsApp failed: {e}")


def escalate_to_human(request):
    session_id = request.session.get('chat_session_id')
    user = request.user if request.user.is_authenticated else None

    if not user or not session_id:
        return redirect('home')

    # Create Ticket automatically
    ticket = Ticket.objects.create(
        user=user,
        subject="AI Chat Escalation - Customer requested live agent",
        description="Customer escalated from AI support chat. Full conversation linked below.",
        priority="Medium",
        ai_chat_session_id=session_id
    )

    # Send notifications with phone & ticket
    send_escalation_notification(user, session_id, ticket)

    # Clear chat session
    ChatMessage.objects.filter(session_id=session_id).delete()
    if 'chat_session_id' in request.session:
        del request.session['chat_session_id']

    return render(request, 'shop/escalate.html', {
        'message': f'Thank you! Ticket #{ticket.id} has been created. Our team will contact you shortly on your registered phone or email.',
        'ticket_id': ticket.id
    })


def send_ticket_reply_email(ticket, reply_text):
    subject = f"Re: Support Ticket #{ticket.id} - Banshix"
    message = f"""
Hello {ticket.user.username},

We have updated your support ticket:

{reply_text}

Ticket Status: {ticket.status}
Priority: {ticket.priority}

Thank you for shopping with Banshix!
Best regards,
Banshix Support Team
New York, USA
    """
    email = EmailMessage(subject, message, settings.DEFAULT_FROM_EMAIL, [
                         ticket.user.email])
    email.send(fail_silently=False)


def send_ticket_reply_whatsapp(ticket, reply_text):
    try:
        client = Client(settings.TWILIO_ACCOUNT_SID,
                        settings.TWILIO_AUTH_TOKEN)
        profile = getattr(ticket.user, 'profile', None)
        customer_phone = profile.phone if profile and profile.phone else None
        if not customer_phone:
            return False

        whatsapp_body = f"""
*Banshix Support Reply - Ticket #{ticket.id}*

Status: {ticket.status}
Priority: {ticket.priority}

{reply_text}

Thank you!
Banshix Team 🇳🇬
        """.strip()

        client.messages.create(
            body=whatsapp_body,
            from_=settings.TWILIO_WHATSAPP_NUMBER,
            to=f"whatsapp:{customer_phone}"
        )
        return True
    except Exception as e:
        print(f"WhatsApp reply failed: {e}")
        return False


def my_tickets(request):
    if not request.user.is_authenticated:
        messages.success(request, "login to create or view ticket")
        return redirect('account_login')

    tickets = Ticket.objects.filter(user=request.user).order_by('-created_at')
    return render(request, 'shop/my_tickets.html', {'tickets': tickets})


@login_required
def ticket_detail(request, ticket_id):
    ticket = get_object_or_404(Ticket, id=ticket_id, user=request.user)
    replies = ticket.replies.all()
    # Include linked AI chat messages if available
    chat_messages = []
    if ticket.ai_chat_session_id:
        chat_messages = ChatMessage.objects.filter(
            session_id=ticket.ai_chat_session_id).order_by('created_at')

    return render(request, 'shop/ticket_detail.html', {
        'ticket': ticket,
        'replies': replies,
        'chat_messages': chat_messages
    })


@login_required
def admin_reply_to_ticket(request, ticket_id):
    if not request.user.is_staff:
        return redirect('home')

    ticket = get_object_or_404(Ticket, id=ticket_id)

    if request.method == 'POST':
        reply_text = request.POST.get('reply_text', '').strip()
        channel = request.POST.get('channel', 'email')
        attachment = request.FILES.get('attachment')  # Handle uploaded file

        if reply_text:
            reply = TicketReply.objects.create(
                ticket=ticket,
                user=request.user,
                message=reply_text,
                is_from_admin=True,
                attachment=attachment
            )

            ticket.status = 'In Progress'
            ticket.save()

            send_customer_reply_notification(
                ticket, reply_text, channel, reply.attachment)

            messages.success(
                request, f"Reply sent via {channel} for Ticket #{ticket.id}")
            return redirect('admin:shop_ticket_change', ticket.id)

    return redirect('admin:shop_ticket_change', ticket.id)


@user_passes_test(lambda u: u.is_staff)
def all_tickets_dashboard(request):
    tickets = Ticket.objects.all().select_related('user').order_by('-created_at')

    # Filters
    status = request.GET.get('status')
    priority = request.GET.get('priority')
    if status:
        tickets = tickets.filter(status=status)
    if priority:
        tickets = tickets.filter(priority=priority)

    # Search functionality
    query = request.GET.get('q')
    if query:
        tickets = tickets.filter(
            Q(id__icontains=query) |
            Q(user__username__icontains=query) |
            Q(user__email__icontains=query) |
            Q(subject__icontains=query) |
            Q(description__icontains=query) |
            Q(ai_chat_session_id__icontains=query)
        )

    return render(request, 'shop/all_tickets.html', {
        'tickets': tickets,
        'status_choices': Ticket.STATUS_CHOICES,
        'priority_choices': Ticket.PRIORITY_CHOICES,
        'query': query,  # Pass back for search box persistence
    })


@login_required
def ticket_reply_customer(request, ticket_id):
    ticket = get_object_or_404(Ticket, id=ticket_id, user=request.user)

    if request.method == 'POST':
        message = request.POST.get('message', '').strip()
        attachment = request.FILES.get('attachment')

        if message:
            TicketReply.objects.create(
                ticket=ticket,
                user=request.user,
                message=message,
                is_from_admin=False,
                attachment=attachment
            )

            # Optional: Notify staff about customer reply
            send_staff_customer_reply_notification(ticket, message)

            messages.success(request, "Your reply has been sent successfully.")
            return redirect('ticket_detail', ticket_id=ticket.id)

    return redirect('ticket_detail', ticket_id=ticket.id)


def recommendations(request):
    recent = request.session.get('recent', [])
    products = Product.objects.filter(id__in=recent)[:4]
    return render(request, 'shop/partials/_recommendations.html', {'products': products})


@login_required
def site_statistics(request):
    daily = SiteVisit.objects.order_by('-date')[:30]
    
    monthly = SiteVisit.objects.annotate(month=TruncMonth('date')) \
        .values('month') \
        .annotate(total=Sum('daily_visits')) \
        .order_by('-month')
    
    yearly = SiteVisit.objects.annotate(year=TruncYear('date')) \
        .values('year') \
        .annotate(total=Sum('daily_visits')) \
        .order_by('-year')
    
    context = {
        'daily_visits': daily,
        'monthly_visits': monthly,
        'yearly_visits': yearly,
        'total_visitors': SiteVisit.objects.aggregate(total=Sum('daily_visits'))['total'] or 0,
    }
    return render(request, 'shop/site_statistics.html', context)


def toggle_like(request, product_id):
    
    product = get_object_or_404(Product, id=product_id)
    liked = request.session.get('liked_products', [])
    
    if product_id in liked:
        liked.remove(product_id)
        product.likes = max(0, product.likes - 1)
    else:
        liked.append(product_id)
        product.likes += 1
    
    request.session['liked_products'] = liked
    product.save()
    
    return JsonResponse({'likes': product.likes, 'liked': product_id in liked})

def toggle_wishlist(request, product_id):
    
    if not request.user.is_authenticated:
        if request.headers.get("HX-Request"):
            response = HttpResponse(status=401)
            response["HX-Redirect"] = "/accounts/login/"
            messages.info(request, "Please log in to manage your wishlist.")
            return response

        messages.info(request, "Please log in to manage your wishlist.")
        return redirect("account_login")
    
    product = get_object_or_404(Product, id=product_id)
    
    # Check if user already has this product in wishlist
    wishlist_item = Wishlist.objects.filter(user=request.user, product=product).first()
    
    if wishlist_item:
        # Remove from wishlist
        wishlist_item.delete()
        in_wishlist = False
    else:
        # Add to wishlist
        Wishlist.objects.create(user=request.user, product=product)
        in_wishlist = True
    
    # Get updated count
    wishlist_count = product.wishlist_set.count()
    
    return JsonResponse({
        'wishlist_count': wishlist_count,
        'in_wishlist': in_wishlist
    })
   


def set_currency(request):
    currency_code = request.GET.get('currency')
    
    if currency_code in settings.CURRENCIES:
        request.session['currency'] = currency_code
        request.session.modified = True
        return JsonResponse({'status': 'ok'})
    
    return JsonResponse({'status': 'error'}, status=400)