"""
Frontend views to display products dynamically
"""
from django.shortcuts import render, redirect, get_object_or_404
from django.contrib.auth.decorators import login_required
from products.models import Product, Category
from accounts.models import Wishlist
from django.db.models import Avg, Q
from django.views.decorators.csrf import ensure_csrf_cookie
from django.db.models.functions import Coalesce
from django.http import HttpResponse
from .models import HeroImage
from ai_features.models import AIConfiguration
from django.utils import timezone
from decimal import Decimal, InvalidOperation




@ensure_csrf_cookie
def index(request):
    """
    Homepage view - displays dynamic products from database
    """
    # Get Hero Images
    hero_ads_left = HeroImage.objects.filter(is_active=True, position='LEFT')
    hero_ads_right = HeroImage.objects.filter(is_active=True, position='RIGHT')

    # Get featured products (only from active vendors or site-owned)
    featured_products = Product.objects.filter(
        Q(vendor__isnull=True) | Q(vendor__status='ACTIVE'),
        is_active=True,
        is_featured=True
    ).select_related('category', 'vendor').prefetch_related('images')[:8]

    # Get active sales (Flash Deals)
    now = timezone.now()
    sale_products = Product.objects.filter(
        Q(vendor__isnull=True) | Q(vendor__status='ACTIVE'),
        is_active=True,
        sale_price__gt=0
    ).filter(
        Q(sale_start__lte=now) | Q(sale_start__isnull=True),
        Q(sale_end__gte=now) | Q(sale_end__isnull=True)
    ).select_related('category', 'vendor').prefetch_related('images').order_by('sale_end')[:8]
    
    # Get all active categories
    categories = Category.objects.filter(
        is_active=True,
        parent=None  # Only top-level categories
    )[:6]
    
    # Get best sellers (only from active vendors or site-owned)
    best_sellers = Product.objects.filter(
        Q(vendor__isnull=True) | Q(vendor__status='ACTIVE'),
        is_active=True,
        is_best_seller=True
    ).select_related('category', 'vendor')[:4]
    
    # Get new arrivals (only from active vendors or site-owned)
    new_arrivals = Product.objects.filter(
        Q(vendor__isnull=True) | Q(vendor__status='ACTIVE'),
        is_active=True,
        is_new_arrival=True
    ).select_related('category', 'vendor').order_by('-created_at')[:4]
    
    # AI-Powered Personalized Recommendations
    from products.ai_recommendations import recommender
    
    # Get personalized recommendations (or trending for anonymous users)
    recommended_for_you = recommender.get_personalized_recommendations(
        request.user if request.user.is_authenticated else None,
        limit=8
    )
    
    # Get trending products
    trending_products = recommender.get_trending_products(limit=6)
    
    context = {
        'featured_products': featured_products,
        'sale_products': sale_products,
        'categories': categories,
        'best_sellers': best_sellers,
        'new_arrivals': new_arrivals,
        'recommended_for_you': recommended_for_you,
        'trending_products': trending_products,
        'hero_ads_left': hero_ads_left,
        'hero_ads_right': hero_ads_right,
    }
    
    return render(request, 'index.html', context)


@ensure_csrf_cookie
def products_list(request):
    """
    Products listing page with AI-powered search
    """
    # Check if search query exists
    search_query = request.GET.get('search')
    
    if search_query:
        # Use AI-powered smart search
        from products.ai_recommendations import smart_search
        
        filters = {}
        if request.GET.get('category'):
            filters['category'] = request.GET.get('category')
        
        if request.GET.get('min_price'):
            try:
                filters['min_price'] = Decimal(request.GET.get('min_price'))
            except (ValueError, TypeError, InvalidOperation):
                pass
                
        if request.GET.get('max_price'):
            try:
                filters['max_price'] = Decimal(request.GET.get('max_price'))
            except (ValueError, TypeError, InvalidOperation):
                pass
        
        products = smart_search.search(search_query, filters=filters)
    else:
        # Regular browsing - show all active products from approved vendors
        products = Product.objects.filter(
            vendor__status='ACTIVE',
            is_active=True
        ).select_related('category', 'vendor').prefetch_related('images')
        
        # Filter by category if provided
        category_slug = request.GET.get('category')
        if category_slug:
            products = products.filter(category__slug=category_slug)

        # Filter by sale status
        if request.GET.get('on_sale'):
             now = timezone.now()
             products = products.filter(
                sale_price__gt=0
            ).filter(
                Q(sale_start__lte=now) | Q(sale_start__isnull=True),
                Q(sale_end__gte=now) | Q(sale_end__isnull=True)
            )

        # Filter by price range
        min_price = request.GET.get('min_price')
        max_price = request.GET.get('max_price')
        
        if min_price or max_price:
            products = products.annotate(effective_price=Coalesce('sale_price', 'price'))
            
            if min_price:
                try:
                    products = products.filter(effective_price__gte=Decimal(min_price))
                except (ValueError, TypeError, InvalidOperation):
                    pass
            
            if max_price:
                try:
                    products = products.filter(effective_price__lte=Decimal(max_price))
                except (ValueError, TypeError, InvalidOperation):
                    pass
    
    sort = request.GET.get('sort')
    if sort and hasattr(products, 'order_by'):
        if sort in ['price-low', 'price-high']:
            products = products.annotate(effective_price=Coalesce('sale_price', 'price'))
            products = products.order_by('effective_price' if sort == 'price-low' else '-effective_price')
        elif sort == 'newest':
            products = products.order_by('-created_at')
        elif sort == 'popular':
            products = products.order_by('-sales_count', '-views_count')
        elif sort == 'rating':
            products = products.annotate(avg_rating=Avg('reviews__rating')).order_by('-avg_rating')
    elif sort:
        def _cur_price(p):
            return float(p.sale_price or p.price or 0)
        if sort == 'price-low':
            products = sorted(products, key=_cur_price)
        elif sort == 'price-high':
            products = sorted(products, key=_cur_price, reverse=True)
        elif sort == 'newest':
            products = sorted(products, key=lambda p: p.created_at, reverse=True)
        elif sort == 'popular':
            products = sorted(products, key=lambda p: (p.sales_count, p.views_count), reverse=True)
        elif sort == 'rating':
            products = sorted(products, key=lambda p: getattr(p, 'average_rating', 0), reverse=True)
    
    wishlist_product_ids = []
    if request.user.is_authenticated:
        wishlist_product_ids = list(
            Wishlist.objects.filter(user=request.user).values_list('product_id', flat=True)
        )
    
    from cart.models import Cart, CartItem
    cart_product_ids = []
    cart = None
    if request.user.is_authenticated:
        cart = Cart.objects.filter(user=request.user).first()
    else:
        session_key = request.session.session_key
        if session_key:
            cart = Cart.objects.filter(session_key=session_key).first()
    if cart:
        cart_product_ids = list(
            CartItem.objects.filter(cart=cart).values_list('product_id', flat=True)
        )
    
    context = {
        'products': products,
        'categories': Category.objects.filter(is_active=True),
        'search_query': search_query,
        'wishlist_product_ids': wishlist_product_ids,
        'cart_product_ids': cart_product_ids,
    }
    
    return render(request, 'products/list.html', context)


@ensure_csrf_cookie
def product_detail(request, slug):
    """
    Product detail page
    """
    from django.shortcuts import get_object_or_404
    
    product = get_object_or_404(
        Product.objects.select_related('category').prefetch_related('images', 'reviews'),
        slug=slug,
        is_active=True
    )
    
    in_wishlist = False
    if request.user.is_authenticated:
        in_wishlist = Wishlist.objects.filter(user=request.user, product=product).exists()
    
    from cart.models import Cart, CartItem
    in_cart = False
    cart = None
    if request.user.is_authenticated:
        cart = Cart.objects.filter(user=request.user).first()
    else:
        session_key = request.session.session_key
        if session_key:
            cart = Cart.objects.filter(session_key=session_key).first()
    if cart:
        in_cart = CartItem.objects.filter(cart=cart, product=product).exists()
    
    # Increment views count
    product.views_count += 1
    product.save(update_fields=['views_count'])
    
    # AI-Powered Recommendations
    from products.ai_recommendations import recommender
    
    # Get similar products using AI
    similar_products = recommender.get_similar_products(product, limit=4)
    
    # Get frequently bought together
    frequently_bought = recommender.get_frequently_bought_together(product.id, limit=4)
    
    # Get personalized "You may also like"
    you_may_like = recommender.get_you_may_also_like(request.user, product, limit=4)
    
    context = {
        'product': product,
        'in_cart': in_cart,
        'in_wishlist': in_wishlist,
        'similar_products': similar_products,
        'frequently_bought': frequently_bought,
        'you_may_like': you_may_like,
    }
    
    return render(request, 'products/detail.html', context)


def terms_of_service(request):
    """
    Terms of Service page
    """
    return render(request, 'legal/terms_of_service.html')


@login_required
def my_orders_view(request):
    """
    Customer's order history page
    """
    from orders.models import Order
    
    orders = Order.objects.filter(user=request.user).order_by('-created_at')
    
    context = {
        'orders': orders,
    }
    
    return render(request, 'pages/my_orders.html', context)


@login_required
def order_detail_view(request, order_code):
    """
    Detailed order tracking page
    """
    from orders.models import Order, OrderItem
    
    order = get_object_or_404(Order, order_code=order_code, user=request.user)
    order_items = OrderItem.objects.filter(order=order).select_related('product')
    
    context = {
        'order': order,
        'order_items': order_items,
    }
    
    return render(request, 'pages/order_detail.html', context)


def privacy_policy(request):
    """
    Privacy Policy page
    """
    return render(request, 'legal/privacy_policy.html')


@login_required
def maintenance_off(request):
    """
    Allow superuser/admin to turn off maintenance mode without admin panel
    """
    user = request.user
    if not (getattr(user, 'is_superuser', False) or getattr(user, 'is_admin', False)):
        return HttpResponse('Forbidden', status=403)
    config = AIConfiguration.get_settings()
    if config:
        config.maintenance_mode = False
        config.maintenance_end_time = None
        config.save(update_fields=['maintenance_mode', 'maintenance_end_time', 'updated_by', 'updated_at'])
        cache.delete('ai_configuration')
    return redirect('/')

def categories_view(request):
    """
    Categories listing page
    """
    from products.models import Category
    categories = Category.objects.filter(is_active=True, parent=None)
    return render(request, 'pages/categories.html', {'categories': categories})


def about_view(request):
    """
    About Us page
    """
    return render(request, 'pages/about.html')


def softwares(request):
    """
    Software Development Services Page
    """
    return render(request, 'softwares.html')


def contact_view(request):
    """
    Contact Us page
    """
    if request.method == 'POST':
        # Handle contact form submission
        from django.contrib import messages
        messages.success(request, 'Thank you for your message! We will get back to you soon.')
        return redirect('frontend:contact')
    
    return render(request, 'pages/contact.html')


@ensure_csrf_cookie
def cart_view(request):
    """
    Shopping Cart page - Use cart app's view
    """
    from cart.views import cart_view as cart_view_func
    return cart_view_func(request)


@ensure_csrf_cookie
def wishlist_view(request):
    """
    Wishlist page
    """
    wishlist_items = []
    if request.user.is_authenticated:
        wishlist_items = Wishlist.objects.filter(user=request.user).select_related('product')
    return render(request, 'pages/wishlist.html', {'wishlist_items': wishlist_items})


@login_required
def checkout_view(request):
    """
    Checkout page with cart items
    """
    from cart.models import Cart, CartItem
    from accounts.models import Address
    
    # Get or create cart
    cart, created = Cart.objects.get_or_create(user=request.user)
    
    cart_items = CartItem.objects.filter(cart=cart).select_related('product')
    
    context = {
        'cart': cart,
        'cart_items': cart_items,
        'addresses': Address.objects.filter(user=request.user),
    }
    
    return render(request, 'pages/checkout.html', context)