from django.shortcuts import render, get_object_or_404, redirect
from django.http import JsonResponse
from core.models import Logs, LogDetails, Wallet, Order, Cart, ViewLog, Contact, Transaction_History, Category, LogOrder, Shopviaclone22, DollarRate, Payment, Accsmtp, Bank_Account, ProfileDetails, Clonevn
from django.db.models import Sum
import uuid
from django.core.files.base import ContentFile
from userauths.models import User
import shortuuid
import requests
from django.template.loader import render_to_string
from django.views.decorators.csrf import csrf_exempt
from django.core.mail import EmailMessage
from django.contrib.auth.decorators import login_required
import json
from django.contrib import messages
from django.core.files.storage import default_storage
from django.core.files import File
from django.conf import settings
import os
from django.contrib.auth import authenticate, login, logout
from django.core.paginator import Paginator
    
def index(request):
    if request.user.is_authenticated:
        if request.user.is_superuser == True:
            return redirect("bstatistics")
        else:
            return redirect("new")
    else:
        # return redirect("b_index")
        
        if request.method == "POST":
            username = request.POST.get("email")
            password = request.POST.get("password")
            
            user = authenticate(request, username=username, password=password)

            if user is not None:
                login(request, user)
                
                next_url = request.GET.get('next', 'bstatistics')
                return redirect(next_url)
        
    context = {
        "true": True,
    }
    return render(request, "backend/index.html", context)
    
def statistics(request):
    user = User.objects.all()
    new = User.objects.all()[:5]
    wnew = Wallet.objects.all().order_by("-id")[:5]
    order = Order.objects.all()
    dspent = Order.objects.all().aggregate(Sum('amount'))['amount__sum'] or 0
    wall = Wallet.objects.all().aggregate(Sum('balance'))['balance__sum'] or 0
    s2 = Shopviaclone22.objects.all().aggregate(Sum('balance'))['balance__sum'] or 0
    # all = All.objects.all().aggregate(Sum('balance'))['balance__sum'] or 0
    API = float(s2)
    # pending = Order.objects.filter(status="Pending").count()
    # completed = Order.objects.filter(status="Completed").count()
    # processing = Order.objects.filter(status="Processing").count()
    # progress = Order.objects.filter(status="In progress").count()
    # partial = Order.objects.filter(status="Partial").count()
    # canceled = Order.objects.filter(status="Canceled").count()
    # refunded = Order.objects.filter(status="Refunded").count()
    PERCENTAGE_PROFIT = Shopviaclone22.objects.last().percentage
    
    # popular_products = (
    #     Order.objects.values('service')
    #     .annotate(count=Count('id'))
    #     .order_by('-count')[:10]  # ⬅️ Limit to top 10
    # )
    
    # today = timezone.now().date()
    # last_30_days = today - timedelta(days=30)

    # Profit for today
    # daily_profit_qs = (
    #     Order.objects.filter(date__gte=today, status="Completed")
    #     .annotate(
    #         profit=ExpressionWrapper(
    #             F('amount') * PERCENTAGE_PROFIT / 100,  # Dynamically calculate profit percentage
    #             output_field=DecimalField()
    #         )
    #     )
    #     .aggregate(total_profit=Sum('profit'))
    # )
    # daily_profit = daily_profit_qs['total_profit'] or 0

    # Profit for last 30 days
    # monthly_profit_qs = (
    #     Order.objects.filter(date__gte=last_30_days, status="Completed")
    #     .annotate(
    #         profit=ExpressionWrapper(
    #             F('amount') * PERCENTAGE_PROFIT / 100,  # Dynamically calculate profit percentage
    #             output_field=DecimalField()
    #         )
    #     )
    #     .aggregate(total_profit=Sum('profit'))
    # )
    # monthly_profit = monthly_profit_qs['total_profit'] or 0
    
    context = {
        "user": user,
        "order": order,
        "spent": dspent,
        "wall": wall,
        "api": API,
        # "pending": pending,
        # "completed": completed,
        # "processing": processing,
        # "progress": progress,
        # "partial": partial,
        # "canceled": canceled,
        # "refunded": refunded,
        "new": wnew,
        # 'popular_products': popular_products,
        # 'daily_profit': round(daily_profit, 2),
        # 'daily_profit': last_30_days,
        # 'monthly_profit': round(monthly_profit, 2),
    }
        
    return render(request, "backend/statistics.html", context)
    
def orders(request):
    status = request.GET.get("status")
    query = request.GET.get("query", "").lower()
    field = request.GET.get("field")
    page_number = request.GET.get("page", 1)  # get the current page number
    
    # Handle if the user is not authenticated
    if not request.user.is_authenticated:
        return redirect("b_index")
    
    # Handle if the user is not a superuser
    if not request.user.is_superuser:
        return redirect("dashboard")
    
    # Base queryset
    order = Order.objects.all()

    # Handle the search by field
    if field == "id" and query:
        order = order.filter(number_id__icontains=query)
    elif field == "email" and query:
        order = order.filter(user__email__icontains=query)

    # Handle the status filter
    # status_filters = {
    #     "all": Order.objects.all(),
    #     "processing": order.filter(status="Processing"),
    #     "inprogress": order.filter(status="In Progress"),
    #     "pending": order.filter(status="Pending"),
    #     "completed": order.filter(status="Completed"),
    #     "partial": order.filter(status="Partial"),
    #     "canceled": order.filter(status="Canceled"),
    # }

    # if status:
    #     order = status_filters.get(status, order)
    
    order = order.order_by("-id")  # ensure consistent ordering before paginating

    # Apply pagination
    paginator = Paginator(order, 100)  # Show 10 orders per page
    page_obj = paginator.get_page(page_number)

    context = {
        "orders": page_obj,
        "page_obj": page_obj,
    }
    return render(request, "backend/orders.html", context)
    
def view_orderlog(request, id):
    theorder = Order.objects.get(id=id)
    thelogs = LogOrder.objects.filter(order=theorder)
    
    context = {
        "o": theorder,
        "l": thelogs
    }
    
    return render(request, "backend/view-order.html", context)
    
@csrf_exempt    
def order_bulk_cancel(request):
    if request.method == "POST":
        ids = request.POST.get("ids")
        ids_list = ids.split(",")
        
        Order.objects.filter(id__in=ids_list).delete()
        
    context = {
        "message": "Deleted succesfully",
        "status": "success",
    }
    return JsonResponse(context)
    
def category(request):
    cat = Category.objects.all()
    all = Category.objects.all()
    # dea = Category.objects.filter(active=False)
    # a = Category.objects.filter(active=True)
    
    # Handle the status filter
    status = request.GET.get("status")
    
    if status == "0":
        cat = Category.objects.filter(active=False).order_by("-id")
    elif status == "1":
        cat = Category.objects.filter(active=True).order_by("-id")
    elif status == "2":
        cat = Category.objects.all()
    
    # Base queryset
    query = request.GET.get("query")
    field = request.GET.get("field")
    order = Category.objects.all()

    # Handle the search by field
    # if field == "id" and query:
    #     order = order.filter(order_id__icontains=query)
    if field == "name" and query:
        user = order.filter(name__icontains=query)
    
    context = {
        "cat": cat,
        # "dea": dea,
        # "a": a,
        "all": all,
    }
    return render(request, "backend/category.html", context)
    
@csrf_exempt
def category_new(request):
    return render(request, "backend/new-category.html")
    
@csrf_exempt
def category_update(request, id):
    cat = Category.objects.get(id=id)
    
    # if request.method == "POST":
    #     name = request.POST.get("name")
        
    #     cat.name = name
    #     cat.save()
    
    context = {
        "cat": cat,
    }
    return render(request, "backend/edit-category.html", context)
    
@csrf_exempt
def logdetails_update(request, id):
    cat = LogDetails.objects.get(id=id)
    
    # if request.method == "POST":
    #     name = request.POST.get("name")
        
    #     cat.name = name
    #     cat.save()
    
    context = {
        "cat": cat,
    }
    return render(request, "backend/edit-logdetails.html", context)
    
@csrf_exempt    
def logdetails_edit(request, id):
    cat = LogDetails.objects.get(id=id)
    
    if request.method == "POST":
        name = request.POST.get("details")
        link = request.POST.get("link")
        
        cat.details = name
        cat.link = link
        cat.save()
        
    context = {
        "message": "Update Successfully",
        "status": "success",
    }
    return JsonResponse(context)
    
@csrf_exempt    
def category_delete(request, id):
    order = Category.objects.filter(id=id)
    order.delete()
    
    context = {
        "delete": True,
        "message": "Deleted Successfully",
    }
    return JsonResponse(context)
    
@csrf_exempt    
def logdetails_delete(request, id):
    order = LogDetails.objects.filter(id=id)
    order.delete()
    
    context = {
        "delete": True,
        "message": "Deleted Successfully",
    }
    return JsonResponse(context)
    
# Log Part

@csrf_exempt
def log_update(request, id):
    cat = Logs.objects.get(id=id)
    
    # if request.method == "POST":
    #     name = request.POST.get("name")
        
    #     cat.name = name
    #     cat.save()
    
    context = {
        "cat": cat,
    }
    return render(request, "backend/edit-log.html", context)
    
@csrf_exempt    
def log_edit(request, id):
    cat = Logs.objects.get(id=id)
    
    if request.method == "POST":
        des = request.POST.get("des")
        qty = request.POST.get("qty")
        price = request.POST.get("price")
        
        cat.description = des
        cat.qty = qty
        cat.price = price
        cat.save()
        
    context = {
        "message": "Update Successfully",
        "status": "success",
    }
    return JsonResponse(context)
    
@csrf_exempt    
def log_delete(request, id):
    order = Logs.objects.filter(id=id)
    order.delete()
    
    context = {
        "delete": True,
        "message": "Deleted Successfully",
    }
    return JsonResponse(context)

@csrf_exempt    
def category_edit(request, id):
    cat = Category.objects.get(id=id)
    
    if request.method == "POST":
        name = request.POST.get("name")
        
        cat.name = name
        cat.save()
        
    context = {
        "message": "Update Successfully",
        "status": "success",
    }
    return JsonResponse(context)

@csrf_exempt    
def category_create(request):
    
    if request.method == "POST":
        name = request.POST.get("name")
        
        Category.objects.create(
            name=name
        )
        
    context = {
        "message": "Created Successfully",
        "status": "success",
    }
    return JsonResponse(context)
    
def logs(request):
    if request.user.is_authenticated:
        if request.user.is_superuser == True:
            users = User.objects.all().count()
            sales = Order.objects.all().count()
            recent = Logs.objects.all().order_by("-id")
            spent = Order.objects.all().aggregate(Sum('amount'))['amount__sum']
            rate = DollarRate.objects.get(id=1)
            api = Shopviaclone22.objects.get(id=1)
            
            if spent == None:
                bal = "0"
            else:
                bal = spent
        else:
            return redirect("index")
    else:
        return redirect("login")
        
    context = {
            "users": users,
            "sales": sales,
            "logs": recent,
            "spent": bal,
            "rate": rate,
            "api": api,
    }
    return render(request, "core/backend-logs.html", context)
    
def history(request):
    query = request.GET.get("query", "").lower().strip()
    # query = request.GET.get("query", '').strip()
    field = request.GET.get("field")
    # Get current page number from request
    page_number = request.GET.get("page", 1)  # Default to page 1
    
    if request.user.is_authenticated:
        if request.user.is_superuser == True:
            # Get all transaction history and order by id descending
            his = Transaction_History.objects.all().order_by("-id")
            
            order = Transaction_History.objects.all()

            # Handle the search by field
            if field == "email" and query:
                his = order.filter(user__email__icontains=query).order_by("-id")
            elif field == "transaction_id" and query:
                his = order.filter(id__icontains=query).order_by("-id")

            # Apply pagination
            paginator = Paginator(his, 100)  # Show 100 history entries per page
            page_obj = paginator.get_page(page_number)
        else:
            return redirect("dashboard")
    else:
        return redirect("b_index")
    
    context = {
        "his": page_obj,  # Pass the paginated history to the template
        "page_obj": page_obj,  # Optional, useful for pagination controls in template
    }
    return render(request, "backend/history.html", context)
    
def log(request):
    query = request.GET.get("query", "").lower().strip()
    # query = request.GET.get("query", '').strip()
    field = request.GET.get("field")
    # Get current page number from request
    page_number = request.GET.get("page", 1)  # Default to page 1
    
    if request.user.is_authenticated:
        if request.user.is_superuser == True:
            # Get all transaction history and order by id descending
            his = Logs.objects.all().order_by("-id")
            
            order = Logs.objects.all()

            # Handle the search by field
            if field == "name" and query:
                his = order.filter(name__icontains=query).order_by("-id")
            elif field == "transaction_id" and query:
                his = order.filter(id__icontains=query).order_by("-id")

            # Apply pagination
            paginator = Paginator(his, 100)  # Show 100 history entries per page
            page_obj = paginator.get_page(page_number)
        else:
            return redirect("new")
    else:
        return redirect("b_index")
    
    context = {
        "his": page_obj,  # Pass the paginated history to the template
        "page_obj": page_obj,  # Optional, useful for pagination controls in template
    }
    return render(request, "backend/log.html", context)

    
@csrf_exempt    
def history_delete(request, id):
    order = Transaction_History.objects.filter(id=id).order_by("-id")
    order.delete()
    
    context = {
        "delete": True,
        "message": "Deleted Successfully",
    }
    return JsonResponse(context)
    
def log_details(request):
    if request.user.is_authenticated:
        if request.user.is_superuser == True:
            users = User.objects.all().count()
            sales = Order.objects.all().count()
            recent = LogDetails.objects.all().order_by("-id")
            spent = Order.objects.all().aggregate(Sum('amount'))['amount__sum']
            rate = DollarRate.objects.get(id=1)
            api = Shopviaclone22.objects.get(id=1)
            
            if spent == None:
                bal = "0"
            else:
                bal = spent
        else:
            return redirect("index")
    else:
        return redirect("login")
        
    context = {
            "users": users,
            "sales": sales,
            "logs": recent,
            "spent": bal,
            "rate": rate,
            "api": api,
    }
    return render(request, "core/backend-logdetails.html", context)
    
# def category(request):
#     if request.user.is_authenticated:
#         if request.user.is_superuser == True:
#             users = User.objects.all().count()
#             sales = Order.objects.all().count()
#             recent = Category.objects.all().order_by("-id")
#             spent = Order.objects.all().aggregate(Sum('amount'))['amount__sum']
#             rate = DollarRate.objects.last()
#             api = Shopviaclone22.objects.get(id=1)
            
#             if spent == None:
#                 bal = "0"
#             else:
#                 bal = spent
#         else:
#             return redirect("index")
#     else:
#         return redirect("login")
        
#     context = {
#             "users": users,
#             "sales": sales,
#             "category": recent,
#             "spent": bal,
#             "rate": rate,
#             "api": api,
#     }
#     return render(request, "core/backend-category.html", context)
    
def wallet(request):
    if request.user.is_authenticated:
        if request.user.is_superuser == True:
            users = User.objects.all().count()
            sales = Order.objects.all().count()
            recent = Wallet.objects.all()
            spent = Order.objects.all().aggregate(Sum('amount'))['amount__sum']
            rate = DollarRate.objects.get(id=1)
            api = Shopviaclone22.objects.get(id=1)
            
            if spent == None:
                bal = "0"
            else:
                bal = spent
        else:
            return redirect("index")
    else:
        return redirect("login")
        
    context = {
            "users": users,
            "sales": sales,
            "wallet": recent,
            "spent": bal,
            "rate": rate,
            "api": api,
    }
    return render(request, "core/backend-wallet.html", context)
    
def users(request):
    query = request.GET.get("query", "").lower()
    field = request.GET.get("field")
    page_number = request.GET.get("page", 1)

    if request.user.is_authenticated:
        if request.user.is_superuser == True:
            # Base queryset
            user = Wallet.objects.all().order_by("-id")
            order = Wallet.objects.all()

            # Handle the search by field
            if field == "email" and query:
                user = order.filter(user__email__icontains=query).order_by("-id")

            # Apply pagination
            paginator = Paginator(user, 100)  # Show 100 users per page
            page_obj = paginator.get_page(page_number)
        else:
            return redirect("new")
    else:
        return redirect("b_index")

    context = {
        "users": page_obj,
        "page_obj": page_obj,  # Optional, useful for pagination controls
    }
    return render(request, "backend/users.html", context)
    
def logdetails(request):
    query = request.GET.get("query", "").lower()
    field = request.GET.get("field")
    page_number = request.GET.get("page", 1)

    if request.user.is_authenticated:
        if request.user.is_superuser == True:
            # Base queryset
            user = LogDetails.objects.all().order_by("-id")
            order = LogDetails.objects.all()

            # Handle the search by field
            if field == "name" and query:
                user = order.filter(which_log__name__icontains=query).order_by("-id")

            # Apply pagination
            paginator = Paginator(user, 100)  # Show 100 users per page
            page_obj = paginator.get_page(page_number)
        else:
            return redirect("new")
    else:
        return redirect("b_index")

    context = {
        "users": page_obj,
        "page_obj": page_obj,  # Optional, useful for pagination controls
    }
    return render(request, "backend/logdetails.html", context)
    
@csrf_exempt    
def user_delete(request, id):
    order = User.objects.filter(id=id)
    order.delete()
    
    context = {
        "delete": True,
        "message": "Deleted Successfully",
    }
    return JsonResponse(context)

def add_funds(request, id):
    wallet = Wallet.objects.get(id=id)
    
    context = {
        "user": wallet,
    }
    return render(request, "backend/add-funds.html", context)

@csrf_exempt
def save_funds(request, id):
    wallet = Wallet.objects.get(id=id)
    
    if request.method == "POST":
        amount = request.POST.get("amount")
        old_bal = wallet.balance
        new = float(old_bal) + float(amount)
        wallet.balance = new
        wallet.save()
        
        log_it = Transaction_History.objects.create(
            user=request.user,
            feedback=request.user.email,
            amount=amount,
            status="Approved",
        )
        
    context = {
        "status": "success",
        "type": "success",
        "message": "Funds added successfully",
        "notification_type": "place-order",
    }
    return JsonResponse(context)

@csrf_exempt    
def user_bulk(request):
    if request.method == "POST":
        ids = request.POST.get("ids")
        ids_list = ids.split(",")
        
        User.objects.filter(id__in=ids_list).delete()
        
        # for i in ids_list:
        #     code = i
        #     w = User.objects.filter(id=code)
        #     w.delete()
        
    context = {
        "message": "Deleted succesfully",
        "status": "success",
    }
    return JsonResponse(context)
    
def view_order(request, id):
    if request.user.is_authenticated:
        if request.user.is_superuser == True:
            theorder = Order.objects.get(id=id)
        else:
            return redirect("index")
    else:
        return redirect("login")
        
    context = {
        "u": theorder,
    }
    return render(request, "core/view-backend-order.html", context)
    
def view_category(request, id):
    if request.user.is_authenticated:
        if request.user.is_superuser == True:
            theorder = Category.objects.get(id=id)
            
            if request.method == "POST":
                name = request.POST.get('name')
                
                theorder.name = name
                theorder.save()
                
                return redirect("backend-category")
        else:
            return redirect("index")
    else:
        return redirect("login")
        
    context = {
        "u": theorder,
    }
    return render(request, "core/view-backend-category.html", context)
    
def delete_category(request, id):
    if request.user.is_authenticated:
        if request.user.is_superuser == True:
            theorder = Category.objects.get(id=id)
            
            theorder.delete()
            
            return redirect("backend-category")
        else:
            return redirect("index")
    else:
        return redirect("login")
        
def delete_log(request, id):
    if request.user.is_authenticated:
        if request.user.is_superuser == True:
            theorder = Logs.objects.get(id=id)
            
            theorder.delete()
            
            return redirect("backend-logs")
        else:
            return redirect("index")
    else:
        return redirect("login")
        
def delete_log_details(request, id):
    if request.user.is_authenticated:
        if request.user.is_superuser == True:
            theorder = LogDetails.objects.get(id=id)
            
            theorder.delete()
            
            return redirect("backend-log-details")
        else:
            return redirect("index")
    else:
        return redirect("login")

    
def create_category(request):
    if request.user.is_authenticated:
        if request.user.is_superuser == True:
            
            if request.method == "POST":
                name = request.POST.get('name')
                
                create_it = Category.objects.create(
                    name=name,
                )
                
                return redirect("backend-category")
        else:
            return redirect("index")
    else:
        return redirect("login")
        
    return render(request, "core/create-new-category-backend.html")
    
def view_logs(request, id):
    if request.user.is_authenticated:
        if request.user.is_superuser == True:
            theorder = Logs.objects.get(id=id)
            cat = Category.objects.all()
            
            if request.method == "POST":
                name = request.POST.get('name')
                qty = request.POST.get('qty')
                price = request.POST.get('price')
                description = request.POST.get('description')
                
                options = request.POST.get('options')
                
                thecat = Category.objects.get(id=options)
                
                theorder.name = name
                theorder.qty = qty
                theorder.price = price
                theorder.description = description
                theorder.cat = thecat
                theorder.save()
                
                return redirect("backend-logs")
        else:
            return redirect("index")
    else:
        return redirect("login")
        
    context = {
        "u": theorder,
        "cat": cat,
    }
    return render(request, "core/view-backend-logs.html", context)
    
def view_log_details(request, id):
    if request.user.is_authenticated:
        if request.user.is_superuser == True:
            theorder = LogDetails.objects.get(id=id)
            cat = Logs.objects.all()
            
            if request.method == "POST":
                name = request.POST.get('name')
                qty = request.POST.get('qty')
                price = request.POST.get('price')
                description = request.POST.get('description')
                
                options = request.POST.get('options')
                
                thecat = LogDetails.objects.get(id=options)
                
                theorder.details = description
                theorder.which_log = thecat
                theorder.save()
                
                return redirect("backend-log-details")
        else:
            return redirect("index")
    else:
        return redirect("login")
        
    context = {
        "u": theorder,
        "cat": cat,
    }
    return render(request, "core/view-backend-log-details.html", context)
    
def create_logs(request):
    if request.user.is_authenticated:
        if request.user.is_superuser == True:
            cat = Category.objects.all()
            
            if request.method == "POST":
                name = request.POST.get('name')
                qty = request.POST.get('qty')
                price = request.POST.get('price')
                description = request.POST.get('description')
                
                options = request.POST.get('options')
                
                thecat = Category.objects.get(id=options)
                
                create_it = Logs.objects.create(
                    name=name,
                    qty=qty,
                    price=price,
                    description=description,
                    cat=thecat,
                )
                
                return redirect("backend-logs")
        else:
            return redirect("index")
    else:
        return redirect("login")
        
    context = {
        "cat": cat,
    }
    return render(request, "core/create-new-log-backend.html", context)
    
def view_wallet(request, id):
    if request.user.is_authenticated:
        if request.user.is_superuser == True:
            theorder = Wallet.objects.get(id=id)
            
            if request.method == "POST":
                balance = request.POST.get('balance')
                
                theorder.balance = balance
                theorder.save()
                
                return redirect("backend-wallet")
        else:
            return redirect("index")
    else:
        return redirect("login")
        
    context = {
        "u": theorder,
    }
    return render(request, "core/view-backend-wallet.html", context)
    
def bulk(request):
    log = Logs.objects.filter(from_api=False, from_acc=False)
    if request.user.is_authenticated:
        if request.user.is_superuser == True:
            if request.method == 'POST':
                options = request.POST.get("options")
                the_log = Logs.objects.get(id=options)
            
                uploaded_file = request.FILES.get("description")
            
                if not uploaded_file:
                    messages.error(request, "No file uploaded")
                    # return redirect("new")
            
                # Read file content
                file_data = uploaded_file.read().decode("utf-8")
            
                details_list = file_data.strip().splitlines()
            
                logdetails_instances = []
            
                for line in details_list:
                    if not line.strip():
                        continue
            
                    if '#Link#' in line:
                        detail, link = line.split('#Link#', 1)
                        link = link.strip()
                    else:
                        detail = line
                        link = ''
            
                    logdetails_instances.append(
                        LogDetails(
                            which_log=the_log,
                            details=detail.strip(),
                            link=link,
                        )
                    )
            
                LogDetails.objects.bulk_create(logdetails_instances)
            
                # Update qty
                new_qty = LogDetails.objects.filter(which_log=the_log, used=False).count()
                Logs.objects.filter(id=the_log.id).update(qty=new_qty)
            
                messages.success(request, "Bulk Uploaded Successfully")
            # else:
            #     return redirect("new")
    else:
        return redirect("b_index")
        
    context = {
        "log": log,
    }
    return render(request, "backend/bulk.html", context)
    
def bulk_profile(request):
    log = Logs.objects.filter(from_api=False, from_acc=False)
    if request.user.is_authenticated:
        if request.user.is_superuser == True:
            if request.method == 'POST':
                options = request.POST.get("options")
                
                the_log = Logs.objects.get(id=options)
                details = request.POST.get("description")
                
                details_list = details.split('*Next*')
                logdetails_instances = [ProfileDetails(which_log=the_log, details=detail.strip()) for detail in details_list if detail.strip()]
                ProfileDetails.objects.bulk_create(logdetails_instances)
                
                messages.success(request, "Bulk Uploaded Successfully")
                # return redirect("backend-logs")
        else:
            return redirect("new")
    else:
        return redirect("b_index")
        
    context = {
        "log": log,
    }
    return render(request, "backend/bulk-profile.html", context)
    
# def delete_manual(request, id):
#     if request.user.is_authenticated:
#         if request.user.is_superuser == True:
#             theorder = Manual_Deposit.objects.get(id=id)
#             theorder.delete()
                
#             return redirect("backend-manual")
#         else:
#             return redirect("index")
#     else:
#         return redirect("login")
    
    
# def view_manual(request, id):
#     if request.user.is_authenticated:
#         if request.user.is_superuser == True:
#             theorder = Manual_Deposit.objects.get(id=id)
            
#             if request.method == "POST":
#                 # amount = request.POST.get('amount')
#                 status = request.POST.get('status')
                
#                 theorder.status = status
#                 theorder.save()
                
#                 # use = theorder.amount
#                 # Update User Balance
                
#                 amount = theorder.amount
#                 duser = theorder.user
#                 wallet = Wallet.objects.get(user=duser)
#                 bal = wallet.balance
#                 add = amount
#                 toge = float(bal) + float(add)
#                 wallet.balance = toge
#                 wallet.save()
                
                
#                 return redirect("backend-manual")
#         else:
#             return redirect("index")
#     else:
#         return redirect("login")
        
#     context = {
#         "u": theorder,
#     }
#     return render(request, "core/view-backend-manual.html", context)

# def manual(request):
#     if request.user.is_authenticated:
#         if request.user.is_superuser == True:
#             users = User.objects.all().count()
#             sales = Order.objects.all().count()
#             recent = Manual_Deposit.objects.filter(status="Pending")
            
#         else:
#             return redirect("index")
#     else:
#         return redirect("login")
        
#     context = {
#             "users": users,
#             "sales": sales,
#             "manual": recent,
#     }
#     return render(request, "core/backend-manual.html", context)
    
def provider(request):
    provider = Shopviaclone22.objects.all()
    p = Clonevn.objects.all()
    
    context = {
        "pro": provider,
        "p": p,
    }
    return render(request, "backend/provider.html", context)

@csrf_exempt    
def api_balance(request, id):
    details = Shopviaclone22.objects.get(id=1)
    # url = f"https://shopviaclone22.com/api/profile.php?api_key={details.username}"
    
    url = f"https://shopviaclone22.com/api/profile.php?api_key={details.username}"

    payload={}
    headers = {}
    
    response = requests.request("GET", url, headers=headers, data=payload)
    
    data = response.json()
    
    mone = data["data"]["money"]

    money = "$" + mone
    
    print(money)
    
    details.balance = money
    details.save()
    
    context = {
        "list": money,
        "the": money,
        "bal": money,
        "message": money,
    }
    return JsonResponse(context)
    
@csrf_exempt
def provider_edit(request):
    current = Shopviaclone22.objects.last()
    drate = DollarRate.objects.last()
    
    context = {
        "api": current,
        "d": drate,
    }
    return render(request, "backend/edit-provider.html", context)
    
@csrf_exempt
def accsprovider_edit(request):
    current = Accsmtp.objects.last()
    drate = DollarRate.objects.last()
    
    context = {
        "api": current,
        "d": drate,
    }
    return render(request, "backend/edit-accs-provider.html", context)
    
@csrf_exempt
def payment(request):
    pay = Payment.objects.all()
    
    context = {
        "pay": pay,
    }
    return render(request, "backend/payment.html", context)

@csrf_exempt    
def api_account_list(request):
    logs = Logs.objects.filter(from_api=True)
    delete_cat = Category.objects.filter(from_api=True)
    
    logs.delete()
    delete_cat.delete()
    details = Shopviaclone22.objects.get(id=1)
    dollar = DollarRate.objects.get(id=1)
    rate = dollar.rate
    username = details.username
    passw = details.password
    tty = details.percentage
    percentage = float(tty)
            
    url = f"https://shopviaclone22.com/api/products.php?api_key={details.username}"
    
    payload={}
    headers = {}
    
    response = requests.request("GET", url, headers=headers, data=payload)
    
    res = response.text
    
    data = response.json()


    categories = data.get("categories", [])
    for category in categories:
        category_name = category.get("name", "Unknown Category")
        category_id = category.get("id", "Unknown Category")
        category_icon = category.get("icon", "https://certimarketplace.com/shopviaclone22.com/assets/storage/images/logo_dark_BUP.png")
        # print(f"Category: {category_name}")
        # print(f"    ID: {category_id}")
        
        if category_id == "77":
            continue
        
        create_cat = Category.objects.create(
            name=category_name,
            from_api=True,
            image=category_icon,
        )
    
        accounts = category.get("products", [])
        for account in accounts:
            account_name = account.get("name", "Unknown Account")
            account_price = account.get("price", "Unknown Price")
            naira_price = float(account_price) * float(rate)
            increase = (percentage / 100) * naira_price
            new_val = float(naira_price) + float(percentage)
            new_value = naira_price + increase
            account_description = account.get("description", "No Description")
            account_id = account.get("id", "No Description")
            account_amount = account.get("amount", "No Description")
            account_country = account.get("country", "No Description")
            # print(f"  Account: {account_name}")
            # print(f"    Price: {naira_price}")
            # print(f"    Description: {account_description}")
            # print(f"    ID: {account_id}")
            # print(f"    Amount: {account_amount}")
            # print(f"    Country: {account_country}")
            # print("-" * 50)
            
            create_log = Logs.objects.create(
                name=account_name,
                description=account_description,
                cat=create_cat,
                from_api=True,
                api_id=account_id,
                country=account_country,
                qty=account_amount,
                price=new_val,
            )
            
            # delete_vpn = Category.objects.get(cat_id=9)
            # delete_vpn.delete()

    
    # print(response.text)
    
    context = {
        "list": res,
        "message": "Update Successfully",
        "status": "success",
    }
    return JsonResponse(context)
    
@csrf_exempt
def provider_update(request):
    change = Shopviaclone22.objects.last()
    ex = DollarRate.objects.last()
    
    per = request.POST.get("per")
    rate = request.POST.get("rate")
    
    change.percentage = per
    change.save()
    ex.rate = rate
    ex.save()
    
    context = {
        "message": "Update Successfully",
        "status": "success",
    }
    return JsonResponse(context)
    
@csrf_exempt
def accsprovider_update(request):
    change = Accsmtp.objects.last()
    ex = DollarRate.objects.last()
    
    per = request.POST.get("per")
    rate = request.POST.get("rate")
    
    change.percentage = per
    change.save()
    ex.rate = rate
    ex.save()
    
    context = {
        "message": "Update Successfully",
        "status": "success",
    }
    return JsonResponse(context)
    
@csrf_exempt    
def clone_shop_api_account_list(request):
    # Clean up old cloned data
    Logs.objects.filter(from_acc=True).delete()
    Category.objects.filter(from_acc=True).delete()
    
    # Get clone credentials and conversion rates
    details = Clonevn.objects.last()
    dollar = DollarRate.objects.last()
    rate = dollar.rate
    percentage = float(details.percentage)
    
    
    allowed_category_ids = ["100", "107", "76", "68", "56", "72", "73", "74", "105", "101", "106", "55"]  # 🔁 <-- Replace with your desired category IDs (as strings)

    # Make request to external API
    url = f"https://clonevn.net/api/products.php?api_key={details.username}"
    headers = {
        "User-Agent": "Mozilla/5.0",
        "Accept": "application/json"
    }
    
    response = requests.get(url, headers=headers)
    
    try:
        data = response.json()
    except Exception as e:
        return JsonResponse({
            "message": f"Failed to parse JSON: {str(e)}",
            "status": "error"
        }, status=500)
    
    categories = data.get("categories", [])
    
    for category in categories:
        category_id = str(category.get("id", ""))
        
        # ✅ Skip if category ID is not in allowed list
        if category_id not in allowed_category_ids:
            continue
        
        category_name = category.get("name", "Unknown Category")
        category_icon = category.get("icon", "https://logshubsocials.com/shopviaclone22.com/assets/storage/images/logo_dark_BUP.png")
        
        create_cat = Category.objects.create(
            name=category_name,
            from_acc=True,
            image=category_icon,
            cat_id=category_id,
        )
        
        accounts = category.get("products", [])
        for account in accounts:
            account_name = account.get("name", "Unknown Account")
            account_price = float(account.get("price", 0))
            dollar_price = account_price * 0.000038
            naira_price = float(dollar_price) * float(rate)
            increase = (percentage / 100) * naira_price
            final_price = naira_price + increase
            
            Logs.objects.create(
                name=account_name,
                description=account.get("description", ""),
                cat=create_cat,
                from_acc=True,
                api_id=account.get("id", ""),
                country=account.get("country", ""),
                qty=account.get("amount", "0"),
                price=final_price,
            )
    
    return JsonResponse({
        "message": "Update Successfully",
        "status": "success"
    })
    
@csrf_exempt
def clone_shop_provider_update(request):
    change = Clonevn.objects.last()
    ex = DollarRate.objects.last()
    
    per = request.POST.get("per")
    rate = request.POST.get("rate")
    
    change.percentage = per
    change.save()
    ex.rate = rate
    ex.save()
    
    context = {
        "message": "Update Successfully",
        "status": "success",
    }
    return JsonResponse(context)
    
@csrf_exempt    
def clone_shop_api_balance(request, id):
    details = Clonevn.objects.last()
    # url = f"https://clonevn.net/api/profile.php?api_key={details.usjername}"
    
    url = f"https://clonevn.net/api/profile.php?api_key={details.username}"

    payload={}
    headers = {}
    
    response = requests.request("GET", url, headers=headers, data=payload)
    
    data = response.json()
    
    mone = data["data"]["money"]

    money = "$" + mone
    
    print(money)
    
    details.balance = money
    details.save()
    
    context = {
        "list": money,
        "the": money,
        "bal": money,
        "message": money,
    }
    return JsonResponse(context)
    
@csrf_exempt
def clone_shop_provider_edit(request):
    current = Clonevn.objects.last()
    drate = DollarRate.objects.last()
    
    context = {
        "api": current,
        "d": drate,
    }
    return render(request, "backend/clone-shop-edit-provider.html", context)
    
def add_new_log(request):
    cat = Category.objects.filter(from_api=False, from_acc=False)
    
    if request.method == "POST":
        name = request.POST.get("log")
        image = request.FILES.get("log_image")
        category = request.POST.get("log_cat")
        description = request.POST.get("description")
        price = request.POST.get("log_price")
        qty = request.POST.get("log_qty")
        
        create_log = Logs.objects.create(
            name=name,
            cat=Category.objects.get(id=category),
            image=image,
            description=description,
            price=price,
            qty=qty,
        )
        
        return redirect("bulk")
    
    context = {
        "c": cat,
    }
    return render(request, "backend/new-log.html", context)
    
def lout(request):
    logout(request)
    return redirect("b_index")