from django.utils import timezone
from django.shortcuts import render, redirect
from django.contrib.auth import authenticate, login, logout
from django.contrib.auth.models import User
from django.contrib.auth.decorators import login_required
from django.contrib import messages
from django.db.models import Q
from svs_traders_admin.models import Product, Category, Slider, Testimonial, Contact, FAQ, PageHit
from django.core.paginator import Paginator
from django.template.loader import render_to_string
from django.utils.http import urlsafe_base64_encode, urlsafe_base64_decode
from django.contrib.auth.tokens import default_token_generator
from django.core.mail import EmailMultiAlternatives
from django.utils.encoding import force_bytes, force_str
from django.conf import settings
from django.db.models import Count
from django.db.models.functions import TruncMonth
from django.http import JsonResponse
from django.utils import timezone
# Create your views here.

@login_required(login_url='system_login')
def dashboard(request):
    product_count = Product.objects.all().count()
    category_count = Category.objects.all().count()
    testimonial_count = Testimonial.objects.all().count()
    contact_count = Contact.objects.all().count()
    now = timezone.localtime(timezone.now())
    return render(request, 'svs_traders_admin/dashboard.html', {
        'product_count': product_count,
        'category_count': category_count,
        'testimonial_count': testimonial_count,
        'contact_count': contact_count,
        'now': now,})



def system_login(request):
    if request.method == 'POST':
        username = request.POST.get('username')
        password = request.POST.get('password')
        user = authenticate(request, username=username, password=password)
        if user is not None:
            login(request, user)
            messages.success(request, f"login success")
            return redirect('dashboard')
        else:
            messages.error(request, f"Invalid credential")
            return redirect('dashboard')
    return render(request, 'svs_traders_admin/system_login.html')



def staff_password_reset_request(request):
    """
    Custom view to handle password reset for admin/staff only.
    """
    try:
        if request.method == "POST":
            email = request.POST.get('email')
            users = User.objects.filter(email__iexact=email, is_active=True)
            if users.exists():
                subject = "Password Reset Requested"
                token = default_token_generator.make_token(users.first())
                uid = urlsafe_base64_encode(force_bytes(users.first().pk))
                reset_link = f"{request.scheme}://{request.get_host()}/reset/{uid}/{token}/"
                message = render_to_string("email/password_reset_email.html", {
                    'user': users.first(),
                    'protocol': request.scheme,
                    'domain': request.get_host(),
                    'uid': uid,
                    'token': token,
                    'reset_link': reset_link,
                })
                try:
                    msg = EmailMultiAlternatives(subject, "", settings.DEFAULT_FROM_EMAIL, [users.first().email])
                    msg.attach_alternative(message, "text/html")
                    msg.send()
                except:
                    messages.error(request, 'Unable to send email.')
                    return redirect('password_reset')

                #messages.success(request, 'A password reset link has been sent to your email.')
                return redirect('password_reset_done')
            else:
                messages.error(request, 'No active user found with that email.')

        return render(request, "svs_traders_admin/password_reset_form.html")
    except Exception as e:
        messages.error(request, f'{e}. Unable to do this action.')
        return render(request, "svs_traders_admin/password_reset_form.html")


# STEP 2 — Password Reset Done
def password_reset_done(request):
    return render(request, "svs_traders_admin/password_reset_done.html")


# STEP 3 — Password Reset Confirm (Link Landing)
def password_reset_confirm(request, uidb64, token):
    try:
        try:
            uid = force_str(urlsafe_base64_decode(uidb64))
            user = User.objects.get(pk=uid, is_active=True)
        except (TypeError, ValueError, OverflowError, User.DoesNotExist):
            user = None

        if user is not None and default_token_generator.check_token(user, token):
            if request.method == "POST":
                password = request.POST.get('password')
                confirm_password = request.POST.get('confirm_password')
                if password == confirm_password:
                    user.set_password(confirm_password)
                    user.save()
                    messages.success(request, "Your password has been set.")
                    return redirect("password_reset_complete")
            return render(request, "svs_traders_admin/password_reset_confirm.html")
        else:
            messages.error(request, "The reset link is invalid or has expired.")
            return redirect("password_reset_request")
    except Exception as e:
        messages.error(request, f'{e}. Unable to do this action.')
        return redirect("password_reset_request")


# STEP 4 — Password Reset Complete
def password_reset_complete(request):
    return render(request, "svs_traders_admin/password_reset_complete.html")



@login_required(login_url='system_login')
def admin_categories(request):
    # Get the search query from GET parameters
    query = request.GET.get('q', '')

    # Filter categories if query exists
    if query:
        categories = Category.objects.filter(name__icontains=query).order_by('id')
        messages.info(request, f"Search results for '{query}'")
    else:
        categories = Category.objects.all().order_by('id')
    
    pagination = Paginator(categories, 10)
    page_number = request.GET.get('page')
    categories = pagination.get_page(page_number)
    return render(request, 'svs_traders_admin/categories.html', {'categories': categories, 'query': query})


@login_required(login_url='system_login')
def admin_add_category(request):
    if request.method == 'POST':
        name = request.POST.get('category_name')
        slug = request.POST.get('category_slug')

        if Category.objects.filter(name__iexact=name).exists():
            messages.warning(request, f"Category '{name}' already exists.")
            return redirect('admin_categories')
        
        if Category.objects.filter(slug=slug).exists():
            messages.warning(request, f"Slug '{slug}' is already used by another category.")
            return redirect('admin_categories')

        Category.objects.create(name=name, slug=slug)
        messages.success(request, f"Category '{name}' added successfully.")
        return redirect('admin_categories')
    
    return redirect('admin_categories')


@login_required(login_url='system_login')
def admin_edit_category(request, category_id):
    category = Category.objects.get(id=category_id)
    if not category:
        messages.error(request, "Category not found.")
        return redirect('admin_categories')

    if request.method == 'POST':
        name = request.POST.get('category_name')
        slug = request.POST.get('category_slug')

        if Category.objects.filter(name__iexact=name).exclude(id=category_id).exists():
            messages.warning(request, f"Category '{name}' already exists.")
            return redirect('admin_categories')
        
        if Category.objects.filter(slug=slug).exclude(id=category_id).exists():
            messages.warning(request, f"Slug '{slug}' is already used by another category.")
            return redirect('admin_categories')

        category.name = name
        category.slug = slug
        category.save()

        messages.success(request, f"Category '{name}' updated successfully.")
        return redirect('admin_categories')

    return redirect('admin_categories')


@login_required(login_url='system_login')
def admin_delete_category(request, category_id):
    category = Category.objects.get(id=category_id)
    if not category:
        messages.error(request, "Category not found.")
        return redirect('admin_categories')
    if category.products.all().exists():
        messages.error(request, "Category linked with products.")
        return redirect('admin_categories')
    
    if request.method == "POST":
        category.delete()
        messages.success(request, f"Category '{category.name}' deleted successfully.")
        return redirect('admin_categories')

    return redirect('admin_categories'), {'category': category}


@login_required(login_url='system_login')
def admin_products(request):
    query = request.GET.get('q', '')
    if query:
        products = Product.objects.filter(Q(name__icontains=query) | Q(category__name__icontains=query))
        messages.info(request, f"Search results for '{query}'")
    else:
        products = Product.objects.all().order_by('id')
    categories = Category.objects.all()
    pagination = Paginator(products, 10)  # Show 10 products per page
    page_number = request.GET.get('page')
    products = pagination.get_page(page_number)
    return render(request, 'svs_traders_admin/products.html', {'categories': categories, 'products': products, 'query': query})


@login_required(login_url='system_login')
def admin_add_product(request):
    if request.method == 'POST':
        name = request.POST.get('name')
        image = request.FILES.get('image')
        category_id = request.POST.get('category_id')
        stock = True if request.POST.get('stock') == "in_stock" else False
        if not name or not image or not category_id:
            messages.error(request, "All fields are required.")
            return redirect('admin_products')
        if image.size > 1 * 1024 * 1024:  # 1MB limit
            messages.error(request, "Image size should not exceed 1MB.")
            return redirect('admin_products')
        if Product.objects.filter(name=name).exists():
            messages.error(request, "Product with this name already exists.")
            return redirect('admin_products')
        category = Category.objects.filter(id=category_id).first()
        if not category:
            messages.error(request, "Selected category does not exist.")
            return redirect('admin_products')
        slug = name.lower().replace(" ", "-")
        if Product.objects.filter(slug=slug).exists():
            slug = f"{slug}-{Product.objects.count()+1}"
        Product.objects.create(name=name, image=image, category=category, slug=slug, in_stock=stock)
        messages.success(request, f"Product {name} added successfully.")
        return redirect('admin_products')
    else:
        messages.error(request, "Invalid request method.")
        return redirect('admin_products')


@login_required(login_url='system_login')
def admin_edit_product(request, product_id):
    product = Product.objects.filter(id=product_id).first()
    if not product:
        messages.error(request, "Product not found.")
        return redirect('admin_products')
    if request.method == 'POST':
        name = request.POST.get('name')
        image = request.FILES.get('image')
        category_id = request.POST.get('category_id')
        stock = request.POST.get('stock')
        if not name or not category_id:
            messages.error(request, "Name and category are required.")
            return redirect('admin_products')
        if image and image.size > 1 * 1024 * 1024:  # 1MB limit
            messages.error(request, "Image size should not exceed 1MB.")
            return redirect('admin_products')
        if Product.objects.filter(name=name).exclude(id=product_id).exists():
            messages.error(request, "Another product with this name already exists.")
            return redirect('admin_products')
        category = Category.objects.filter(id=category_id).first()
        if not category:
            messages.error(request, "Selected category does not exist.")
            return redirect('admin_products')
        product.name = name
        slug = name.lower().replace(" ", "-")
        if Product.objects.filter(slug=slug).exclude(id=product_id).exists():
            slug = f"{slug}-{Product.objects.count()+1}"
        product.slug = slug
        product.category = category
        if stock == "in_stock":
            product.in_stock = True
        else:
            product.in_stock = False
        if image:
            product.image = image
        product.save()
        messages.success(request, f"Product {name} updated successfully.")
        return redirect('admin_products')
    else:
        return redirect('admin_products')


@login_required(login_url='system_login')
def admin_delete_product(request, product_id):
    product = Product.objects.filter(id=product_id).first()
    if not product:
        messages.error(request, "Product not found.")
        return redirect('admin_products')
    if request.method == 'POST':
        product.delete()
        messages.success(request, "Product deleted successfully.")
        return redirect('admin_products')
    else:
        messages.error(request, "Invalid request method.")
        return redirect('admin_products')


@login_required(login_url='system_login')
def admin_testimonials(request):
    query = request.GET.get('q', '')
    if query:
        testimonials = Testimonial.objects.filter(Q(name__icontains=query) | Q(message__icontains=query))
        messages.info(request, f"Search results for '{query}'")
    else:
        testimonials = Testimonial.objects.all()
    pagination = Paginator(testimonials, 10)  # Show 10 testimonials per page
    page_number = request.GET.get('page')
    testimonials = pagination.get_page(page_number)
    return render(request, 'svs_traders_admin/testimonials.html', {'testimonials': testimonials, 'query': query})


@login_required(login_url='system_login')
def admin_delete_testimonial(request, testimonial_id):
    testimonial = Testimonial.objects.filter(id=testimonial_id).first()
    if not testimonial:
        messages.error(request, "Testimonial not found.")
        return redirect('admin_testimonials')
    if request.method == 'POST':
        testimonial.delete()
        messages.success(request, "Testimonial deleted successfully.")
        return redirect('admin_testimonials')
    else:
        messages.error(request, "Invalid request method.")
        return redirect('admin_testimonials')


@login_required(login_url='system_login')
def admin_faqs(request):
    query = request.GET.get('q', '')
    if query:
        faqs = FAQ.objects.filter(Q(question__icontains=query) | Q(answer__icontains=query))
        messages.info(request, f"Search results for '{query}'")
    else:
        faqs = FAQ.objects.all()
    pagination = Paginator(faqs, 10)
    page_number = request.GET.get('page')
    faqs = pagination.get_page(page_number)
    return render(request, 'svs_traders_admin/faqs.html', {'faqs': faqs, 'query': query})



@login_required(login_url='system_login')
def admin_add_faq(request):
    if request.method == 'POST':
        question = request.POST.get('faq_question')
        answer = request.POST.get('faq_answer')

        if FAQ.objects.filter(question__iexact=question).exists():
            messages.warning(request, f"FAQ '{question}' already exists.")
            return redirect('admin_faqs')

        FAQ.objects.create(question=question, answer=answer)
        messages.success(request, f"FAQ '{question}' added successfully.")
        return redirect('admin_faqs')
    
    return redirect('admin_faqs')


@login_required(login_url='system_login')
def admin_edit_faq(request, faq_id):
    faq = FAQ.objects.get(id=faq_id)
    if not faq:
        messages.error(request, "FAQs not found.")
        return redirect('admin_faqs')

    if request.method == 'POST':
        question = request.POST.get('faq_question')
        answer = request.POST.get('faq_answer')

        if FAQ.objects.filter(question__iexact=question).exclude(id=faq_id).exists():
            messages.warning(request, f"FAQ '{question}' already exists.")
            return redirect('admin_faqs')

        faq.question = question
        faq.answer = answer
        faq.save()

        messages.success(request, f"FAQ '{question}' updated successfully.")
        return redirect('admin_faqs')

    return redirect('admin_faqs')


@login_required(login_url='system_login')
def admin_delete_faq(request, faq_id):
    faq = FAQ.objects.get(id=faq_id)
    if not faq:
        messages.error(request, "FAQ not found.")
        return redirect('admin_faqs')
    
    if request.method == "POST":
        faq.delete()
        messages.success(request, f"FAQ '{faq.question}' deleted successfully.")
        return redirect('admin_faqs')

    return redirect('admin_faqs'), {'faq': faq}



@login_required(login_url='system_login')
def admin_contacts(request):
    query = request.GET.get('q', '').lower()
    if query:
        contacts = Contact.objects.filter(
            Q(name__icontains=query) |
            Q(email__icontains=query) |
            Q(message__icontains=query)
        )        
        messages.info(request, f"Search results for '{query}'")
    else:
        contacts = Contact.objects.all()
    pagination = Paginator(contacts, 10)  # Show 10 contacts per page
    page_number = request.GET.get('page')
    contacts = pagination.get_page(page_number)
    return render(request, 'svs_traders_admin/contacts.html', {'contacts': contacts, 'query': query})


@login_required(login_url='system_login')
def admin_delete_contact(request, contact_id):
    contact = Contact.objects.filter(id=contact_id).first()
    if not contact:
        messages.error(request, "Message not found.")
        return redirect('admin_contacts')
    if request.method == 'POST':
        contact.delete()
        messages.success(request, "Message deleted successfully.")
        return redirect('admin_contacts')
    else:
        messages.error(request, "Invalid request method.")
        return redirect('admin_contacts')
    

@login_required(login_url='system_login')
def admin_settings(request):
    if request.method == 'POST':
        for i in range(1, 4):  # Loop through 3 slides
            desktop_image = request.FILES.get(f'desktop_image_{i}')
            mobile_image = request.FILES.get(f'mobile_image_{i}')
            caption = request.POST.get(f'slide_text_{i}')

            slider, created = Slider.objects.get_or_create(slide_number=i)

            # Only update fields if new values provided
            if desktop_image:
                slider.desktop_image = desktop_image
            if mobile_image:
                slider.mobile_image = mobile_image
            if caption is not None:
                slider.caption = caption

            slider.save()

        messages.success(request, "Slides updated successfully.")
        return redirect('admin_settings')

    slides = {s.slide_number: s for s in Slider.objects.all()}
    return render(request, 'svs_traders_admin/web_settings.html', {'slide1': slides.get(1), 'slide2': slides.get(2), 'slide3': slides.get(3)})


def system_logout(request):
    logout(request)
    return redirect('system_login')


def monthly_pagehits_api(request):
    now = timezone.now()
    start = (now.replace(day=1) - timezone.timedelta(days=365)).replace(day=1)
    qs = (PageHit.objects
          .filter(created_at__gte=start)
          .annotate(month=TruncMonth("created_at"))
          .values("month")
          .annotate(hits=Count("id"))
          .order_by("month"))

    labels = []
    data = []
    months = []
    for i in range(12):
        m = (now.replace(day=1) - timezone.timedelta(days=30*i))
        months.append(m.replace(day=1))
    months = sorted(set(months))

    counts = {row["month"].date(): row["hits"] for row in qs}
    for dt in months:
        labels.append(dt.strftime("%b %Y"))
        data.append(counts.get(dt.date(), 0))

    return JsonResponse({"labels": labels, "data": data})


def category_distribution_api(request):
    qs = (Product.objects
          .values("category__name")   # assuming FK Product -> Category
          .annotate(count=Count("id"))
          .order_by("category__name"))

    labels = [row["category__name"] or "Uncategorized" for row in qs]
    data = [row["count"] for row in qs]

    return JsonResponse({"labels": labels, "data": data})
