from appservices.common.util import *
from flask import session
admin = Blueprint("admin",__name__)


@admin.route("/test_server",methods=["GET"])
def test_server():
    return "Server check successful!"

# Admin Create API
@admin.route("/create_admin",methods=["POST"])
def create_admin():
    data_status={"responseStatus":0,"result":""}
    userName = request.json.get("userName","")
    email = request.json.get("email","")
    password = request.json.get("password","")
    phoneNumber = request.json.get("phoneNumber","")
    profilePicture = request.json.get("profilePicture","")

    if userName and email and password and phoneNumber:
        try:
            admin_create_table=SuperAdmin(
                userName=userName,
                email=email,
                password=generate_password_hash(password),
                phoneNumber=phoneNumber,
                createdOn=datetime.datetime.now(),
                status=1
                )
            admin_save=admin_create_table.save()
            adminId=str(admin_save.id)          
            data_status["responseStatus"]=1
            data_status["result"]="Admin created successfully!"
            return data_status
        except Exception as e:
            app.logger.error(traceback.format_exc())
            data_status["result"]="Unable to create admin!!"
            return data_status
    else:
        data_status["result"]="Required fields are missing!"
        return data_status

# Old Admin Login Code
# @admin.route("/admin_login",methods=["POST","GET"])
# def admin_login():
#     data_status={"responseStatus":0,"result":""}
#     email=request.form.get("email","")
#     password=request.form.get("password","")

#     if email and password:
#         try:
#             admin_queryset=SuperAdmin.objects(email__iexact=email).first()
#             if admin_queryset:
#                 adminId = str(admin_queryset.id)
#                 if check_password_hash(admin_queryset.password,password):
#                     if admin_queryset.status == 1:
#                         adminData=fetch_admin_details(admin_queryset)
#                         first_chars = re.findall(r'\b\w', admin_queryset.userName)
#                         imageString = ''.join(first_chars)

#                         # permissionsList = check_permissions(str(admin_queryset.id),"")

#                         session["adminId"] = str(admin_queryset.id)
#                         session["userName"] = admin_queryset.userName
#                         session["imageString"] = imageString
#                         # session["permissionsList"] = permissionsList
#                         return redirect(url_for("admin.dashboard"))
#                     else:
#                         error = "In-active account!"
#                         return render_template("super_admin_templates/admin_login.html",error=error)
#                 else:
#                     error = "Wrong password!"
#                     return render_template("super_admin_templates/admin_login.html",error=error)
#             else:
#                 error = "Invaild email id!"
#                 return render_template("super_admin_templates/admin_login.html",error=error)
#         except Exception as e:
#             app.logger.error(traceback.format_exc())
#             return render_template("super_admin_templates/admin_login.html")
#     else:
#         error = ""
#         return render_template("super_admin_templates/admin_login.html",error=error)

@admin.route("/admin_login", methods=["POST", "GET"])
def admin_login():
    data_status = {"responseStatus": 0, "result": ""}
    email = request.form.get("email", "")
    password = request.form.get("password", "")
    userAgent = request.headers.get("User-Agent")

    loginBrowser = request.headers.get("Sec-Ch-Ua")
    if loginBrowser:
        loginBrowseData = loginBrowser.split(";")
        browser = loginBrowseData[0]
    else:
        loginBrowseData = request.headers.get('User-Agent').split(";")
        browser = loginBrowseData[0]

    existing_record=""
    client_ip=0
    # Extracting client IP address
    if request.headers.getlist("X-Forwarded-For"): 
        client_ip = request.headers.getlist("X-Forwarded-For")[0]
    else:
        client_ip = request.remote_addr

    actionDate=datetime.datetime.now()

    jsonData = request.form.to_dict(flat=True)

    requestData = [existing_record]
    updatedrequestData = [jsonData]
    save_admin_log_table = save_admin_logs_data(None,None,None,"admin_login","login",actionDate,client_ip,browser,"",requestData,updatedrequestData)
    print(str(save_admin_log_table.id),"((((((((save_admin_log_table))))))))")

    if email and password:
        try:
            admin_queryset = SuperAdmin.objects(email__iexact=email).first()
            if admin_queryset:
                if check_password_hash(admin_queryset.password, password):
                    phoneNumber=str(admin_queryset.phoneNumber)
                    if admin_queryset.status == 1:
                        message=admin_queryset.userName+" admin login successfully!"

                        save_admin_log_table.update(message=message,adminId=ObjectId(admin_queryset.id))
                        authenticationEnabled=admin_queryset.authenticationEnabled
                        if authenticationEnabled == True:
                            # otpCode = str(random.randint(100000, 999999))
                            status=0
                            try:
                                # smsmessage="Your Graam Pay Admin Login OTP is "+str(otpCode)
                                otpType = "Common_Otp"
                                adminName = str(admin_queryset.userName)
                                smsresponse=send_sms(phoneNumber,otpType,adminName)
                                print(smsresponse,"((((((((((smsresponse))))))))))")
                                otpCode = smsresponse.get('otp')
                                otpcheck_queryset=OtpChecks(
                                    userId=None,
                                    otpCode=str(otpCode),
                                    phoneNumber=str(phoneNumber),
                                    attempts=0,
                                    status=0,
                                    createdOn=datetime.datetime.now(),
                                    otpReason=message
                                    ).save()
                                otpCheckId=str(otpcheck_queryset.id)

                                try:
                                    # email=admin_queryset.email
                                    email="saikerla@viyonafintech.com"
                                    if email:
                                        mail_subject = "Otp verification for GraamPay Admin Login!"
                                        recipients_list = [email]
                                        template_name = "emails/otpverification.html"
                                        mail_data = {
                                        "merchantName":adminName,
                                        "otpCode":otpCode,
                                        }
                                        send_asynchronous_email(mail_subject, recipients_list, template_name, mail_data)
                                        # mailoutputData = send_asynchronous_email(mail_subject, recipients_list, template_name, mail_data)
                                except Exception as e:
                                    app.logger.error(traceback.format_exc())
                                    pass

                                adminId = str(admin_queryset.id)
                                admin_login_report_table = SuperAdminLogs(
                                    adminId = adminId,
                                    ipAddress = client_ip,
                                    loginBrowser = browser.strip('"'),
                                    userAgent = userAgent,
                                    createdOn = datetime.datetime.now(),
                                    otpCode=str(otpCode),
                                    attempts=0,
                                    authenticationEnabled=authenticationEnabled,
                                    status = status
                                    ).save()
                                adminLogId=str(admin_login_report_table.id)
                            except Exception as e:
                                adminLogId=""
                                app.logger.error(traceback.format_exc())
                                pass
                            return render_template("super_admin_templates/admin_login_otp.html", adminLogId=adminLogId,otpCheckId=otpCheckId)
                        else:
                            try:
                                adminId = str(admin_queryset.id)
                                admin_login_report_table = SuperAdminLogs(
                                    adminId = adminId,
                                    ipAddress = client_ip,
                                    loginBrowser = browser.strip('"'),
                                    userAgent = userAgent,
                                    createdOn = datetime.datetime.now(),
                                    otpCode="",
                                    attempts=0,
                                    authenticationEnabled=authenticationEnabled,
                                    status = 1
                                    ).save()
                                adminLogId=str(admin_login_report_table.id)
                            except Exception as e:
                                adminLogId=""
                                app.logger.error(traceback.format_exc())
                                pass

                            todaySignupCount = 0

                            startDate = datetime.datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
                            endDate = datetime.datetime.now().replace(hour=23, minute=59, second=59, microsecond=999999)
                            merchant_queryset = Users.objects(createdOn__gte=startDate,createdOn__lte=endDate).order_by('-createdOn')
                            todaySignupCount = merchant_queryset.count()
                            merchantList = []
                            for each_merchant in merchant_queryset:
                                merchantDict = {
                                "merchantName":each_merchant.fullName,
                                "createdOn":each_merchant.createdOn.strftime("%d-%m-%Y %H:%M:%S %p")
                                }
                                merchantList.append(merchantDict)

                            adminData=fetch_admin_details(admin_queryset)
                            first_chars = re.findall(r'\b\w', admin_queryset.userName)
                            imageString = ''.join(first_chars)


                            rejected_count = 0
                            pending_count = 0
                            submitted_count = 0
                            approved_count = 0
                            processing_count = 0  
                            pending_user_kyc_count = 0 

                            users_kyc_queryset = UserKYC.objects.filter(status__in=[0, 1]).order_by("-id")
    
                            for each_user_kyc in users_kyc_queryset:
                                
                                kycStatusList = [
                                    each_user_kyc.panStatus,
                                    each_user_kyc.aadharStatus,
                                    each_user_kyc.bankStatus,
                                    each_user_kyc.videoVerificationStatus,
                                    each_user_kyc.agreementVerificationStatus
                                ]

                                non_approved_status_count = len([status for status in kycStatusList if status != "Approved"])

                                if non_approved_status_count > 0:
                                    pending_user_kyc_count += 1

                        
                            session["adminId"] = str(admin_queryset.id)
                            session["userName"] = admin_queryset.userName
                            session["imageString"] = imageString
                            session["pendingUsersCount"] = pending_user_kyc_count
                            session["merchantList"] = merchantList
                            session["todaySignupCount"] = todaySignupCount
                            return redirect(url_for("admin.dashboard"))
                    else:
                        error = "Inactive account!"
                        return render_template("super_admin_templates/admin_login.html", error=error)
                else:
                    error = "Wrong password!"
                    return render_template("super_admin_templates/admin_login.html", error=error)
            else:
                error = "Invalid email id!"
                return render_template("super_admin_templates/admin_login.html", error=error)
        except Exception as e:
            app.logger.error(traceback.format_exc())
            return render_template("super_admin_templates/admin_login.html")
    else:
        # error = "Required fields are missing!!"
        return render_template("super_admin_templates/admin_login.html")


@admin.route("/admin_login_otp", methods=["GET", "POST"])
def admin_login_otp():
    if request.method == "POST":
        otp = request.form.get("otp", "")
        adminLogId = request.form.get("adminLogId")
        otpCheckId = request.form.get("otpCheckId")
        userAgent = request.headers.get("User-Agent")

        loginBrowser = request.headers.get("Sec-Ch-Ua")
        if loginBrowser:
            loginBrowseData = loginBrowser.split(";")
            browser = loginBrowseData[0]
        else:
            loginBrowseData = request.headers.get('User-Agent').split(";")
            browser = loginBrowseData[0]

        client_ip=0
        # Extracting client IP address
        if request.headers.getlist("X-Forwarded-For"): 
            client_ip = request.headers.getlist("X-Forwarded-For")[0]
        else:
            client_ip = request.remote_addr
        requestData = []
        updatedrequestData = []
        actionDate=datetime.datetime.now()
        save_admin_log_table = save_admin_logs_data(None,None,None,"admin_login","login",actionDate,client_ip,browser,"",requestData,updatedrequestData)

        if otp and adminLogId and otpCheckId:
            try:
                admin_queryset = SuperAdminLogs.objects(id=str(adminLogId),status=0).first()
                message=admin_queryset.adminId.userName+" OTP sent successfully!"
                save_admin_log_table.update(message=message,adminId=ObjectId(admin_queryset.adminId.id))
                # attempts=admin_queryset.attempts+1

                otpcheck_querryset=OtpChecks.objects(id=str(otpCheckId),status=0).first()
                if otpcheck_querryset:
                    attempts=otpcheck_querryset.attempts+1
                    if otpcheck_querryset.otpCode==otp:
                        otpcheck_querryset.update(status=1,attempts=attempts)

                        admin_login_queryset = SuperAdmin.objects(id=str(admin_queryset.adminId.id)).first()

                        todaySignupCount = 0

                        startDate = datetime.datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
                        endDate = datetime.datetime.now().replace(hour=23, minute=59, second=59, microsecond=999999)
                        merchant_queryset = Users.objects(createdOn__gte=startDate,createdOn__lte=endDate).order_by('-createdOn')
                        todaySignupCount = merchant_queryset.count()
                        merchantList = []
                        for each_merchant in merchant_queryset:
                            merchantDict = {
                            "merchantName":each_merchant.fullName,
                            "createdOn":each_merchant.createdOn.strftime("%d-%m-%Y %H:%M:%S %p")
                            }
                            merchantList.append(merchantDict)
                        pending_user_kyc_count = UserKYC.objects(status=0).count()
                        
                        session["adminId"] = str(admin_login_queryset.id)
                        session["userName"] = admin_login_queryset.userName
                        session["merchantList"] = merchantList
                        session["pendingUsersCount"] = pending_user_kyc_count
                        first_chars = re.findall(r'\b\w', admin_login_queryset.userName)
                        session["imageString"] = ''.join(first_chars)
                        return redirect(url_for('admin.dashboard'))

                    else:
                        otpcheck_querryset.update(attempts=attempts)
                        error = "Invalid OTP!"
                        return render_template("super_admin_templates/admin_login_otp.html", error=error,adminLogId=adminLogId)
                else:
                    otpcheck_querryset.update(attempts=attempts)
                    error = "Invalid OTP!"
                    return render_template("super_admin_templates/admin_login_otp.html", error=error,adminLogId=adminLogId)
            except Exception as e:
                app.logger.error(traceback.format_exc())
                return redirect(url_for('admin.admin_login'))
        else:
            error = "Please enter the OTP!"
            return render_template("super_admin_templates/admin_login_otp.html", error=error,adminLogId=adminLogId)
    else:
        return render_template("super_admin_templates/admin_login_otp.html",adminLogId=adminLogId)



@admin.route("/dashboard",methods=["POST","GET"])
def dashboard():
    try:
        if not session.get("adminId"):
            return redirect("admin_login")
        adminId = session.get("adminId")

        adminDict = {}
        commissionsDict = {}
        payInTop10MerchantsList = []
        payoutsTop10MerchantsList = []
        payoutsList = []
        payinsList = []
        adminDict = {}
        totalWalletBalance = 0
        merchants_count = 0
        totalPayInBalance = 0
        payinTotalchargeAmount = 0
        payinTotaltdsAmount = 0
        payinTotalgstAmount = 0
        totalPayinAmount = 0
        payoutTotalchargeAmount = 0
        payoutTotaltdsAmount = 0
        payoutTotalgstAmount = 0
        totalPayoutAmount = 0

        admin_queryset = SuperAdmin.objects(id=adminId,status__in=[1]).first()

        #totalWalletBalance = Users.objects(status__in=[1]).sum('walletBalance')

        #merchants_count = Users.objects(status__in=[1]).count()


        totalPayInBalance = WalletTransactions.objects(creditType="Credit",status=1,userType="user").sum('amount')

        totalPayOutBalance = FundTransfers.objects(transferType__nin=["Credit"],status=1,userType__ne='admin').sum('amount')


        # Get the first and last day of the current month
        today = datetime.datetime.today()
        first_day_of_current_month = today.replace(day=1,hour=0, minute=0, second=0, microsecond=0)

        last_day_of_previous_month = first_day_of_current_month - datetime.timedelta(days=1)
        last_day_of_previous_month = last_day_of_previous_month.replace(hour=23, minute=59, second=59, microsecond=59)

        first_day_of_previous_month=last_day_of_previous_month.replace(day=1,hour=0, minute=0, second=0, microsecond=0)

        # Get the last day of the current month
        last_day_of_current_month = first_day_of_current_month + timedelta(days=calendar.monthrange(today.year, today.month)[1] - 1)
        last_day_of_current_month = last_day_of_current_month.replace(hour=23, minute=59, second=59, microsecond=999999)


        # Payout Current Month and Current Year
        totalCurrentMonthPayoutBalance = 0

        totalCurrentMonthPayoutBalance = FundTransfers.objects(createdOn__gte=first_day_of_current_month,createdOn__lte=today,status=1,transferType__nin=["Credit","Refund"],userType__ne='admin').sum("amount")

        totalPreviousMonthPayoutBalance = 0
        totalPreviousMonthPayoutBalance = FundTransfers.objects(createdOn__gte=first_day_of_previous_month,createdOn__lte=last_day_of_previous_month,status=1,transferType__nin=["Credit","Refund"],userType__ne='admin').sum("amount")

        # Payout Increase or Decrease Growth

        if totalPreviousMonthPayoutBalance > 0:
            payoutGrowth = (totalCurrentMonthPayoutBalance - totalPreviousMonthPayoutBalance)*100/totalPreviousMonthPayoutBalance
        else:
            payoutGrowth = 100

        # Payin Current Month and Current Year

        totalCurrentMonthPayinBalance = 0
        totalCurrentMonthPayinBalance = WalletTransactions.objects(createdOn__gte=first_day_of_current_month,createdOn__lte=today,status=1,creditType="Credit",userType="user").sum("amount")

        totalPreviousMonthPayinBalance = 0
        totalPreviousMonthPayinBalance = WalletTransactions.objects(createdOn__gte=first_day_of_previous_month,createdOn__lte=last_day_of_previous_month,status=1,creditType="Credit",userType="user").sum("amount")

        # Payout Increase or Decrease Growth

        if totalPreviousMonthPayinBalance > 0:
            payinGrowth = (totalCurrentMonthPayinBalance - totalPreviousMonthPayinBalance)*100/totalPreviousMonthPayinBalance
        else:
            payinGrowth = 100

        # Payout Balance
        payoutsList = []
        payOutSuccessRatio=0
        transaction_apis_queryset = TransactionAPI.objects(transactionType="Payout",status__in=[0,1]).order_by("-id")
        for each_payout in transaction_apis_queryset:
            admin_balance_queryset = AdminPayoutBalances.objects(apiTransactionId=str(each_payout.id)).first()
            if admin_balance_queryset:
                previousBalance = admin_balance_queryset.previousBalance
                currentBalance = admin_balance_queryset.currentBalance
                updatedOn = admin_balance_queryset.createdOn.astimezone(ist_timezone).strftime("%d-%m-%Y %I:%M %p")
            else:
                previousBalance = 0
                currentBalance = 0
                updatedOn = datetime.datetime.now().astimezone(ist_timezone).strftime("%d-%m-%Y %I:%M %p")

            
            # PayOut Success Ratio
            payout_success_ratio = FundTransfers.objects(transferType__nin=["Credit","Refund"],transactionAPIId=str(each_payout.id),userType__ne='admin').order_by("-id")
            if payout_success_ratio:
                totalPayOutCount = payout_success_ratio.count()
                totalPayOutSuccessCount = payout_success_ratio.filter(status=1).count()
                payOutSuccessRatio = (totalPayOutSuccessCount*100)/totalPayOutCount
            
            
            payoutDict = {
            "id":str(each_payout.id),
            "apiName":each_payout.apiName,
            "transactionType":each_payout.transactionType,
            "successRatio":"{:.2f}".format(float(payOutSuccessRatio)),
            "updatedOn":updatedOn,
            "previousBalance":formatINR(previousBalance),
            "currentBalance":formatINR("{:.2f}".format(float(currentBalance)))
            }
            payoutsList.append(payoutDict)

        # Payin Balance
        payinsList = []
        payInSuccessRatio=0
        transaction_apis_queryset = TransactionAPI.objects(transactionType="PaymentGateway",status__in=[0,1]).order_by("-id")
        for each_payin in transaction_apis_queryset:
            admin_balance_queryset = PayinBalances.objects(transactionAPIId=str(each_payin.id)).all()
            if admin_balance_queryset:
                currentBalance = admin_balance_queryset.filter().sum('currentBalance')
            else:
                currentBalance = 0

            
            # Payin Success Ratio
            payin_success_ratio = WalletTransactions.objects(paymentGatewayId=str(each_payin.id),status__in=[0,1],creditType="Credit",userType='user').order_by("-id")
            if payin_success_ratio:
                totalPayInCount = payin_success_ratio.count()
                totalPayInSuccessCount = payin_success_ratio.filter(status=1).count()
                payInSuccessRatio = (totalPayInSuccessCount*100)/totalPayInCount
            
            updatedOn = datetime.datetime.now().astimezone(ist_timezone).strftime("%d-%m-%Y %I:%M %p")
            payinDict = {
            "id":str(each_payin.id),
            "apiName":each_payin.apiName,
            "transactionType":each_payin.transactionType,
            "successRatio":"{:.2f}".format(float(payInSuccessRatio)),
            "updatedOn":updatedOn,
            "currentBalance":formatINR("{:.2f}".format(float(currentBalance)))
            }
            payinsList.append(payinDict)


        # Filter for successful PayIn transactions for the current month
        pipeline = [
            {"$lookup": {
                "from": "users",
                "localField": "userId",
                "foreignField": "_id",
                "as": "userDetails"
            }},
            {"$match": {
                "creditType": "Credit",
                "status": 1,
                "userType":"user",
                "createdOn": {
                    "$gte": first_day_of_current_month,
                    "$lte": last_day_of_current_month
                }
            }},
            {"$unwind": "$userDetails"},  # Unwind the array returned by $lookup
            {"$group": {"_id": "$userId", "totalAmount": {"$sum": "$amount"}}},
            {"$sort": {"totalAmount": -1}},
            {"$limit": 10}
        ]
        # print(pipeline,"*********pipeline*********")
        # Execute the aggregation pipeline
        payins_top_10_merchants = list(WalletTransactions.objects.aggregate(*pipeline))
        # print(payins_top_10_merchants,"**********payins_top_10_merchants***********")
        payInTop10MerchantsList = []
        for each_merchant in payins_top_10_merchants:
            merchant_queryset = Users.objects(id=each_merchant.get("_id")).first()
            if merchant_queryset:
                first_chars = re.findall(r'\b\w', merchant_queryset.fullName)

                imageString = ''.join(first_chars)

                payInDict = {
                "merchantId":str(merchant_queryset.id),
                "merchantName":merchant_queryset.fullName,
                "phoneNumber":merchant_queryset.phoneNumber,
                "imageString":imageString,
                "totalMerchantAmount":formatINR("{:.2f}".format(float(each_merchant.get("totalAmount"))))
                }
                payInTop10MerchantsList.append(payInDict)

        # Filter for successful Payout transactions for the current month
        payout_pipeline = [
            {"$match": {
                "transferType": "Debit",
                "userType": {"$ne":"admin"},
                "status": 1,
                "createdOn": {
                    "$gte": first_day_of_current_month,
                    "$lte": last_day_of_current_month
                }
            }},  # Filtering
            {"$group": {"_id": "$userId", "totalAmount": {"$sum": "$amount"}}},  # Grouping and summing amounts
            {"$sort": {"totalAmount": -1}},  # Sorting by total amount in descending order
            {"$limit": 10}  # Limiting to top 10
        ]

        # Execute the aggregation payout_pipeline
        payouts_top_10_merchants = list(FundTransfers.objects.aggregate(*payout_pipeline))
        payoutsTop10MerchantsList = []
        for each_payout_merchant in payouts_top_10_merchants:
            payout_merchant_queryset = Users.objects(id=each_payout_merchant.get("_id")).first()
            if payout_merchant_queryset:
                first_chars = re.findall(r'\b\w', payout_merchant_queryset.fullName)

                imageString = ''.join(first_chars)

                payOutDict = {
                "merchantId":str(payout_merchant_queryset.id),
                "merchantName":payout_merchant_queryset.fullName,
                "phoneNumber":payout_merchant_queryset.phoneNumber,
                "imageString":imageString,
                "totalMerchantAmount":formatINR("{:.2f}".format(float(each_payout_merchant.get("totalAmount"))))
                }
                payoutsTop10MerchantsList.append(payOutDict)

        # Commissions For Payin And Payout Calculations
        payinTotalchargeAmount = WalletTransactions.objects(status=1).sum('commissionCharges.chargeAmount')
        payinTotaltdsAmount = WalletTransactions.objects(status=1).sum('commissionCharges.tdsAmount')
        payinTotalgstAmount = WalletTransactions.objects(status=1).sum('commissionCharges.gstAmount')

        totalPayinAmount  = payinTotalchargeAmount + payinTotaltdsAmount + payinTotalgstAmount

        # print(totalPayinAmount,"totalPayinAmount Commissions")
        
        payoutTotalchargeAmount = FundTransfers.objects(status=1).sum('commissionCharges.chargeAmount')
        payoutTotaltdsAmount = FundTransfers.objects(status=1).sum('commissionCharges.tdsAmount')
        payoutTotalgstAmount = FundTransfers.objects(status=1).sum('commissionCharges.gstAmount')

        totalPayoutAmount  = payoutTotalchargeAmount + payoutTotaltdsAmount + payoutTotalgstAmount

        # print(totalPayoutAmount,"totalPayoutAmount Commissions")
        


        adminDict = {
        "userName":admin_queryset.userName,
        "merchantsCount":merchants_count,
        "payoutGrowth":round(payoutGrowth,2),
        "payinGrowth":round(payinGrowth,2),
        "payInSuccessRatio":round(payInSuccessRatio,2),
        "payOutSuccessRatio":round(payOutSuccessRatio,2),
        "totalPayOutBalance":formatINR("{:.2f}".format(float(totalPayOutBalance))),
        "totalPayInBalance":formatINR("{:.2f}".format(float(totalPayInBalance))),
        "totalWalletBalance":formatINR("{:.2f}".format(float(totalWalletBalance))),
        "totalCurrentMonthPayoutBalance":formatINR("{:.2f}".format(float(totalCurrentMonthPayoutBalance))),
        "totalPreviousMonthPayoutBalance":formatINR("{:.2f}".format(float(totalPreviousMonthPayoutBalance))),
        "totalPreviousMonthPayinBalance":formatINR("{:.2f}".format(float(totalPreviousMonthPayinBalance))),
        "totalCurrentMonthPayinBalance":formatINR("{:.2f}".format(float(totalCurrentMonthPayinBalance))),
        "totalPayinCommissionsAmount":formatINR("{:.2f}".format(float(payinTotalchargeAmount))),
        "totalPayinTdsAmount":formatINR("{:.2f}".format(float(payinTotaltdsAmount))),
        "totalPayinGstAmount":formatINR("{:.2f}".format(float(payinTotalgstAmount))),
        "totalPayoutCommissionsAmount":formatINR("{:.2f}".format(float(payoutTotalchargeAmount))),
        "totalPayoutTdsAmount":formatINR("{:.2f}".format(float(payoutTotaltdsAmount))),
        "totalPayoutGstAmount":formatINR("{:.2f}".format(float(payoutTotalgstAmount))),
        "totalPayoutAmount":formatINR("{:.2f}".format(float(totalPayoutAmount))),
        "totalPayinAmount":formatINR("{:.2f}".format(float(totalPayinAmount))),
        }
        return render_template(
            "super_admin_templates/dashboard.html",
            adminDict=adminDict,
            payInTop10MerchantsList=payInTop10MerchantsList,
            payoutsTop10MerchantsList=payoutsTop10MerchantsList,
            payoutsList=payoutsList,
            payinsList=payinsList,
            )
    except Exception as e:
        app.logger.error(traceback.format_exc())
        return redirect(url_for('admin.admin_login'))

@admin.route("/admin_profile_details",methods=["POST","GET"])
def admin_profile_details():
    try:
        if not session.get("adminId"):
            return redirect("admin_login")

        adminId = session.get("adminId")
        
        admin_queryset = SuperAdmin.objects(id=adminId).first()

        if admin_queryset:
            adminDict = fetch_admin_details(admin_queryset)
            return render_template("super_admin_templates/admin_profile_details.html",adminDict=adminDict)
        else:
            return redirect(url_for('admin.dashboard'))
    except Exception as e:
        app.logger.error(traceback.format_exc())
        return redirect(url_for('admin.dashboard'))


def fetch_admin_details(admin_queryset):
    loginDict={}
    try:
        loginDict={
        "id":str(admin_queryset.id),
        "userName":admin_queryset.userName,
        "email":admin_queryset.email,
        "phoneNumber":admin_queryset.phoneNumber,
        "createdOn":admin_queryset.createdOn.astimezone(tzinfo),
        "status":admin_queryset.status
        }
        if admin_queryset.profilePicture:
            loginDict["profilePicture"]=domain+admin_queryset.profilePicture
        else:
            loginDict["profilePicture"]=""
    except Exception as e:
        app.logger.error(traceback.format_exc())
    return loginDict

@admin.route("/admin_change_password", methods=["POST", "GET"])
def admin_change_password():
    if not session.get("adminId"):
        return redirect(url_for("admin.admin_login"))
    adminId = session.get("adminId")
    loginBrowser = request.headers.get("Sec-Ch-Ua")
    userAgent = request.headers.get("User-Agent")
    if loginBrowser:
        loginBrowseData = loginBrowser.split(";")
        browser = loginBrowseData[0]
    else:
        loginBrowseData = request.headers.get('User-Agent').split(";")
        browser = loginBrowseData[0]

    client_ip=0
    # Extracting client IP address
    if request.headers.getlist("X-Forwarded-For"): 
        client_ip = request.headers.getlist("X-Forwarded-For")[0]
    else:
        client_ip = request.remote_addr

    actionDate=datetime.datetime.now()
    existing_record = ""
    requestData = []
    
    if request.method == "GET":
        print("GET request received.")
        try:
            admin_queryset = SuperAdmin.objects(id=adminId).first()
            existing_record = admin_queryset.to_json()
            updatedrequestData = [existing_record]
            save_admin_log_table = save_admin_logs_data(adminId,None,None,"admin_login","login",actionDate,client_ip,browser,"",requestData,updatedrequestData)
            message=admin_queryset.userName+" Successfully changed the password!"
            save_admin_log_table.update(message=message)

            if not admin_queryset:
                flash("Invalid admin id!")
                return redirect(url_for("admin.admin_login"))
            adminDict = fetch_admin_details(admin_queryset)
            return render_template("super_admin_templates/admin_profile_details.html", adminDict=adminDict)
        except Exception as e:
            app.logger.error(traceback.format_exc())
            flash("Server Connection Error. Please try again!")
            return redirect(url_for("admin.admin_login"))

    if request.method == "POST":
        print("POST request received.")
        oldPassword = request.form.get("oldPassword", "")
        newPassword = request.form.get("newPassword", "")
        confirmNewPassword = request.form.get("confirmNewPassword", "")

        print(f"Form Data: oldPassword={oldPassword}, newPassword={newPassword}, confirmNewPassword={confirmNewPassword}")

        if not oldPassword or not newPassword or not confirmNewPassword:
            flash("Required fields are missing!")
            return redirect(url_for("admin.admin_change_password"))

        try:
            admin_queryset = SuperAdmin.objects(id=adminId).first()
            if not admin_queryset:
                flash("Invalid admin id!")
                return redirect(url_for("admin.admin_login"))

            print(f"Admin Query Result: {admin_queryset}")

            if check_password_hash(admin_queryset.password, oldPassword):
                print("Old password is correct.")
                if newPassword == confirmNewPassword:
                    admin_queryset.update(password=generate_password_hash(newPassword))
                    flash("Successfully changed the password!")
                    return redirect(url_for("admin.admin_change_password"))
                else:
                    flash("New password and confirm new password do not match!")
                    return redirect(url_for("admin.admin_change_password"))
            else:
                flash("Old password is incorrect!")
                return redirect(url_for("admin.admin_change_password"))
        except Exception as e:
            app.logger.error(traceback.format_exc())
            flash("Server Connection Error. Please try again!")
            return redirect(url_for("admin.admin_login"))


# @admin.route("/admin_login_otp", methods=["POST"])
# def admin_login_otp():
#     if not session.get("adminId"):
#         return redirect("admin_login")
#     email=request.form.get("email","")
#     password=request.form.get("password","")
#     otp=request.form.get("otp","")

#     if email and password and otp:
#         try:
#             admin_queryset=SuperAdmin.objects(email=email,status__in=[1]).first()
#             if not admin_queryset:
#                 flash("Please give admin email!")
#                 return redirect(url_for('admin.admin_login'))

#             otp_number = str(random.randint(111111, 999999))

#             admin_queryset.update(otp=otp_number,otpGeneratedOn = datetime.datetime.now())

#             userName=admin_queryset.userName
#             # try:
#             #     adminData={}
#             #     adminData={
#             #     "userName":userName,
#             #     "otp":otp_number,
#             #     "domain":domain
#             #     }
#             #     msg=Message("Reset your password!!",sender=sender_email, recipients=[email])
#             #     msg.html=render_template("admin/password_reset.html",adminInfo=adminData)
#             #     mail.send(msg)
#             # except Exception as e:
#             #     app.logger.error(traceback.format_exc())
#             #     pass
#             return render_template("superadmin/admin_login_otp.html")
#         except Exception as e:
#             app.logger.error(traceback.format_exc())
#             return redirect(url_for('admin.admin_login'))
#     else:
#         return redirect(url_for('admin.admin_login'))

# # Admin password reset API
# @admin.route("/admin_password_reset", methods=["POST"])
# def admin_password_reset():
#     if not session.get("adminId"):
#         return redirect("admin_login")
#     data_status = {"responseStatus": 0, "result": ""}
#     email=request.form.get("email","")

#     if email:
#         try:
#             admin_queryset=MonemeSuperAdmin.objects(email__exact=email,status__in=[1]).first()
#             if not admin_queryset:
#                 data_status["result"]="Admin does not exist with given email!"
#                 return data_status
#             otp_number = str(random.randint(111111, 999999))
#             admin_queryset.update(
#                 otp=generate_password_hash(otp_number),
#                 otpGeneratedOn = datetime.datetime.now()
#                 )
#             userName=admin_queryset.userName
#             try:
#                 adminData={}
#                 adminData={
#                 "userName":userName,
#                 "otp":otp_number,
#                 "domain":domain
#                 }
#                 msg=Message("Reset your password!!",sender=sender_email, recipients=[email])
#                 msg.html=render_template("admin/password_reset.html",adminInfo=adminData)
#                 mail.send(msg)
#             except Exception as e:
#                 app.logger.error(traceback.format_exc())
#                 pass
#             return render_template("superadmin/forgotpassword.html")
#             # data_status["responseStatus"]=1
#             # data_status["result"]="OTP sent, Please check your email!"
#             # return data_status
#         except Exception as e:
#             app.logger.error(traceback.format_exc())
#             return render_template("superadmin/resetPassword.html")
#     else:
#         return render_template("superadmin/resetPassword.html")

# # Admin forgot password API
# @admin.route("/admin_forgot_password", methods=["POST"])
# def admin_forgot_password():
#     if not session.get("adminId"):
#         return redirect("admin_login")
#     data_status = {"responseStatus": 0, "result": ""}
#     otp = request.form.get("otp","")
#     email = request.form.get("email","")
#     newPassword = request.form.get("newPassword","")
#     confirmNewPassword = request.form.get("confirmNewPassword","")

#     if otp and email and newPassword and confirmNewPassword:
#         if newPassword == confirmNewPassword:
#             try:
#                 admin_queryset=MonemeSuperAdmin.objects(email__exact=email,status__in=[1]).first()
#                 if admin_queryset:
#                     otpGeneratedOn = admin_queryset.otpGeneratedOn
#                     currentTime = datetime.datetime.now()
#                     time_diff = currentTime - otpGeneratedOn
#                     if int(time_diff.total_seconds()) > 1800:#30min validity
#                         data_status["result"] = "OTP Expired!"
#                         return data_status
#                     if not admin_queryset.otp:
#                         data_status["result"] = "Wrong OTP!"
#                         return data_status
#                     if check_password_hash(admin_queryset.otp, otp):
#                         admin_queryset.update(password=generate_password_hash(newPassword))
#                         admin_queryset.otp = None
#                         admin_queryset.save()
#                         userName=admin_queryset.userName
#                         try:
#                             adminData={}
#                             adminData={
#                             "userName":userName,
#                             "domain":domain
#                             }
#                             msg=Message("Reset your password!!",sender=sender_email, recipients=[email])
#                             msg.html=render_template("admin/forgot_password.html",adminInfo=adminData)
#                             mail.send(msg)
#                         except Exception as e:
#                             app.logger.error(traceback.format_exc())
#                             pass
#                         return render_template("superadmin/index.html")
#                         # data_status["responseStatus"] = 1
#                         # data_status["result"]="Admin Password Changed Successfully!"
#                         # return data_status
#                     else:
#                         return render_template("superadmin/forgotpassword.html")
#                         # data_status["result"]="Wrong OTP!"
#                         # return data_status
#                 else:
#                     return render_template("superadmin/forgotpassword.html")
#                     # data_status["result"]="Invaild email!"
#                     # return data_status
#             except Exception as e:
#                 app.logger.error(traceback.format_exc())
#                 return render_template("superadmin/forgotpassword.html")
#         else:
#             return render_template("superadmin/forgotpassword.html")
#             # data_status["result"]="New Password and Confirm Password Mis-Matched!!"
#             # return data_status
#     else:
#         return render_template("superadmin/forgotpassword.html")


# @admin.route("/dashboard",methods=["POST","GET"])
# def dashboard():
#     try:
#         if not session.get("adminId"):
#             return redirect("admin_login")
#         adminId = session.get("adminId")

#         payInTop10MerchantsList = []
#         payoutsTop10MerchantsList = []
#         payoutsList = []
#         payinsList = []
#         adminDict = {}
#         totalWalletBalance = 0
#         merchants_count = 0
#         totalPayInBalance = 0

#         admin_queryset = SuperAdmin.objects(id=adminId,status__in=[1]).first()

#         totalWalletBalance = Users.objects(status__in=[1]).sum('walletBalance')

#         merchants_count = Users.objects(status__in=[1]).count()


#         totalPayInBalance = WalletTransactions.objects(creditType="Credit",status=1).sum('amount')

#         totalPayOutBalance = FundTransfers.objects(transferType__nin=["Credit"],status=1).sum('amount')


#         # Get the first and last day of the current month
#         today = datetime.datetime.today()
#         first_day_of_current_month = today.replace(day=1,hour=0, minute=0, second=0, microsecond=0)

#         last_day_of_previous_month = first_day_of_current_month - datetime.timedelta(days=1)
#         last_day_of_previous_month = last_day_of_previous_month.replace(hour=23, minute=59, second=59, microsecond=59)

#         first_day_of_previous_month=last_day_of_previous_month.replace(day=1,hour=0, minute=0, second=0, microsecond=0)

#         # Get the last day of the current month
#         last_day_of_current_month = first_day_of_current_month + timedelta(days=calendar.monthrange(today.year, today.month)[1] - 1)
#         last_day_of_current_month = last_day_of_current_month.replace(hour=23, minute=59, second=59, microsecond=999999)


#         # Payout Current Month and Current Year
#         payout_current_month_pipeline = [
#             {"$match": {"transferType": {"$nin": ["Credit"]}, "status": 1,"createdOn": {"$gte": first_day_of_current_month, "$lte": today}}},  # Filtering
#             {"$group": {"_id": None,"totalAmount": {"$sum": "$amount"}}},  # Grouping and summing amounts
#             {"$sort": {"totalAmount": -1}},  # Sorting by total amount in descending order
#         ]

#         currentMonthTotalPayoutAmount = list(FundTransfers.objects.aggregate(*payout_current_month_pipeline))
#         if currentMonthTotalPayoutAmount == []:
#             totalCurrentMonthPayoutBalance = 0
#         else:
#             totalCurrentMonthPayoutBalance = currentMonthTotalPayoutAmount[0]["totalAmount"]

#         payout_previous_month_pipeline = [
#             {"$match": {"transferType": {"$nin": ["Credit"]}, "status": 1,"createdOn": {"$gte": first_day_of_previous_month, "$lte": last_day_of_previous_month}}},  # Filtering
#             {"$group": {"_id": None,"totalAmount": {"$sum": "$amount"}}},  # Grouping and summing amounts
#             {"$sort": {"totalAmount": -1}},  # Sorting by total amount in descending order
#         ]

#         # Execute the aggregation payout_pipeline
#         previousMonthTotalPayoutAmount = list(FundTransfers.objects.aggregate(*payout_previous_month_pipeline))
#         if previousMonthTotalPayoutAmount == []:
#             totalPreviousMonthPayoutBalance = 0
#         else:
#             totalPreviousMonthPayoutBalance = previousMonthTotalPayoutAmount[0]["totalAmount"]

#         # Payout Increase or Decrease Growth

#         if totalPreviousMonthPayoutBalance > 0:
#             payoutGrowth = (totalCurrentMonthPayoutBalance - totalPreviousMonthPayoutBalance)*100/totalPreviousMonthPayoutBalance
#         else:
#             payoutGrowth = 100



#         # Payin Current Month and Current Year
#         payin_current_month_pipeline = [
#             {"$match": {"creditType": "Credit", "status": 1,"createdOn": {"$gte": first_day_of_current_month, "$lte": today}}},  # Filtering
#             {"$group": {"_id": None,"totalAmount": {"$sum": "$amount"}}},  # Grouping and summing amounts
#             {"$sort": {"totalAmount": -1}},  # Sorting by total amount in descending order
#         ]

#         currentMonthTotalPayinAmount = list(WalletTransactions.objects.aggregate(*payin_current_month_pipeline))
#         if currentMonthTotalPayinAmount == []:
#             totalCurrentMonthPayinBalance = 0
#         else:
#             totalCurrentMonthPayinBalance = currentMonthTotalPayinAmount[0]["totalAmount"]

#         payout_previous_month_pipeline = [
#             {"$match": {"creditType": "Credit", "status": 1,"createdOn": {"$gte": first_day_of_previous_month, "$lte": last_day_of_previous_month}}},  # Filtering
#             {"$group": {"_id": None,"totalAmount": {"$sum": "$amount"}}},  # Grouping and summing amounts
#             {"$sort": {"totalAmount": -1}},  # Sorting by total amount in descending order
#         ]

#         # Execute the aggregation payout_pipeline
#         previousMonthTotalPayinAmount = list(WalletTransactions.objects.aggregate(*payout_previous_month_pipeline))
#         if previousMonthTotalPayinAmount == []:
#             totalPreviousMonthPayinBalance = 0
#         else:
#             totalPreviousMonthPayinBalance = previousMonthTotalPayinAmount[0]["totalAmount"]

#         # Payout Increase or Decrease Growth

#         if totalPreviousMonthPayinBalance > 0:
#             payinGrowth = (totalCurrentMonthPayinBalance - totalPreviousMonthPayinBalance)*100/totalPreviousMonthPayinBalance
#         else:
#             payinGrowth = 100

#         # Payout Balance
#         payoutsList = []
#         transaction_apis_queryset = TransactionAPI.objects(transactionType="Payout",status__in=[0,1]).order_by("-id")
#         for each_payout in transaction_apis_queryset:
#             admin_balance_queryset = AdminPayoutBalances.objects(apiTransactionId=str(each_payout.id)).first()
#             if admin_balance_queryset:
#                 previousBalance = admin_balance_queryset.previousBalance
#                 currentBalance = admin_balance_queryset.currentBalance
#                 updatedOn = admin_balance_queryset.createdOn.astimezone(ist_timezone).strftime("%d-%m-%Y %I:%M %p")
#             else:
#                 previousBalance = 0
#                 currentBalance = 0
#                 updatedOn = datetime.datetime.now().astimezone(ist_timezone).strftime("%d-%m-%Y %I:%M %p")

#             payOutSuccessRatio=0
#             # PayOut Success Ratio
#             payout_success_ratio = FundTransfers.objects(transferType__nin=["Credit"],transactionAPIId=str(each_payout.id)).order_by("-id")
#             if payout_success_ratio:
#                 totalPayOutCount = payout_success_ratio.count()
#                 totalPayOutSuccessCount = payout_success_ratio.filter(status=1).count()
#                 payOutSuccessRatio = (totalPayOutSuccessCount*100)/totalPayOutCount
            
            
#             payoutDict = {
#             "id":str(each_payout.id),
#             "apiName":each_payout.apiName,
#             "transactionType":each_payout.transactionType,
#             "successRatio":"{:.2f}".format(float(payOutSuccessRatio)),
#             "updatedOn":updatedOn,
#             "previousBalance":formatINR(previousBalance),
#             "currentBalance":formatINR("{:.2f}".format(float(currentBalance)))
#             }
#             payoutsList.append(payoutDict)

#         # Payin Balance
#         payinsList = []
#         transaction_apis_queryset = TransactionAPI.objects(transactionType="PaymentGateway",status__in=[0,1]).order_by("-id")
#         for each_payin in transaction_apis_queryset:
#             admin_balance_queryset = PayinBalances.objects(transactionAPIId=str(each_payin.id)).all()
#             if admin_balance_queryset:
#                 currentBalance = admin_balance_queryset.filter().sum('currentBalance')
#             else:
#                 currentBalance = 0

#             payInSuccessRatio=0
#             # Payin Success Ratio
#             payin_success_ratio = WalletTransactions.objects(paymentGatewayId=str(each_payin.id),status__in=[0,1],creditType="Credit").order_by("-id")
#             if payin_success_ratio:
#                 totalPayInCount = payin_success_ratio.count()
#                 totalPayInSuccessCount = payin_success_ratio.filter(status=1).count()
#                 payInSuccessRatio = (totalPayInSuccessCount*100)/totalPayInCount
            
#             updatedOn = datetime.datetime.now().astimezone(ist_timezone).strftime("%d-%m-%Y %I:%M %p")
#             payinDict = {
#             "id":str(each_payin.id),
#             "apiName":each_payin.apiName,
#             "transactionType":each_payin.transactionType,
#             "successRatio":"{:.2f}".format(float(payInSuccessRatio)),
#             "updatedOn":updatedOn,
#             "currentBalance":formatINR("{:.2f}".format(float(currentBalance)))
#             }
#             payinsList.append(payinDict)

#         adminDict = {
#         "userName":admin_queryset.userName,
#         "merchantsCount":merchants_count,
#         "payoutGrowth":payoutGrowth,
#         "payinGrowth":payinGrowth,
#         "payInSuccessRatio":round(payInSuccessRatio,2),
#         "payOutSuccessRatio":round(payOutSuccessRatio,2),
#         "totalPayOutBalance":formatINR("{:.2f}".format(float(totalPayOutBalance))),
#         "totalPayInBalance":formatINR("{:.2f}".format(float(totalPayInBalance))),
#         "totalWalletBalance":formatINR("{:.2f}".format(float(totalWalletBalance))),
#         "totalCurrentMonthPayoutBalance":formatINR("{:.2f}".format(float(totalCurrentMonthPayoutBalance))),
#         "totalPreviousMonthPayoutBalance":formatINR("{:.2f}".format(float(totalPreviousMonthPayoutBalance))),
#         "totalPreviousMonthPayinBalance":formatINR("{:.2f}".format(float(totalPreviousMonthPayinBalance))),
#         "totalCurrentMonthPayinBalance":formatINR("{:.2f}".format(float(totalCurrentMonthPayinBalance))),
#         "totalPayinCommissionsAmount":0,
#         "totalPayinTdsAmount":0,
#         "totalPayinGstAmount":0,
#         "totalPayoutCommissionsAmount":0,
#         "totalPayoutTdsAmount":0,
#         "totalPayoutGstAmount":0,
#         "totalPayoutAmount":0,
#         "totalPayinAmount":0,
#         }
#         return render_template(
#             "super_admin_templates/dashboard.html",
#             adminDict=adminDict,
#             payInTop10MerchantsList=payInTop10MerchantsList,
#             payoutsTop10MerchantsList=payoutsTop10MerchantsList,
#             payoutsList=payoutsList,
#             payinsList=payinsList,
#             )
#     except Exception as e:
#         app.logger.error(traceback.format_exc())
#         return redirect(url_for('admin.admin_login'))

# @admin.route("/dashboard_data",methods=["POST","GET"])
# def dashboard_data():
#     data_status = {"responseStatus":0,"result":""}
#     try:
#         if not session.get("adminId"):
#             data_status['responseStatus']=2
#             return data_status

#         # Get the first and last day of the current month
#         today = datetime.datetime.today()
#         first_day_of_current_month = today.replace(day=1,hour=0, minute=0, second=0, microsecond=0)

#         last_day_of_previous_month = first_day_of_current_month - datetime.timedelta(days=1)
#         last_day_of_previous_month = last_day_of_previous_month.replace(hour=23, minute=59, second=59, microsecond=59)

#         first_day_of_previous_month=last_day_of_previous_month.replace(day=1,hour=0, minute=0, second=0, microsecond=0)

#         # Get the last day of the current month
#         last_day_of_current_month = first_day_of_current_month + timedelta(days=calendar.monthrange(today.year, today.month)[1] - 1)
#         last_day_of_current_month = last_day_of_current_month.replace(hour=23, minute=59, second=59, microsecond=999999)

#         # Filter for successful PayIn transactions for the current month
#         pipeline = [
#             {"$match": {
#                 "creditType": "Credit",
#                 "status": 1,
#                 "createdOn": {
#                     "$gte": first_day_of_current_month,
#                     "$lte": last_day_of_current_month
#                 }
#             }},  # Filtering
#             {"$group": {"_id": "$userId", "totalAmount": {"$sum": "$amount"}}},  # Grouping and summing amounts
#             {"$sort": {"totalAmount": -1}},  # Sorting by total amount in descending order
#             {"$limit": 10}  # Limiting to top 10
#         ]

#         # Execute the aggregation pipeline
#         payins_top_10_merchants = list(WalletTransactions.objects.aggregate(*pipeline))
#         payInTop10MerchantsList = []
#         for each_merchant in payins_top_10_merchants:
#             merchant_queryset = Users.objects(id=each_merchant.get("_id")).first()

#             first_chars = re.findall(r'\b\w', merchant_queryset.fullName)

#             imageString = ''.join(first_chars)

#             payInDict = {
#             "merchantId":str(merchant_queryset.id),
#             "merchantName":merchant_queryset.fullName,
#             "phoneNumber":merchant_queryset.phoneNumber,
#             "imageString":imageString,
#             "totalMerchantAmount":formatINR("{:.2f}".format(float(each_merchant.get("totalAmount"))))
#             }
#             payInTop10MerchantsList.append(payInDict)

#         # Filter for successful Payout transactions for the current month
#         payout_pipeline = [
#             {"$match": {
#                 "transferType": "Debit",
#                 "status": 1,
#                 "createdOn": {
#                     "$gte": first_day_of_current_month,
#                     "$lte": last_day_of_current_month
#                 }
#             }},  # Filtering
#             {"$group": {"_id": "$userId", "totalAmount": {"$sum": "$amount"}}},  # Grouping and summing amounts
#             {"$sort": {"totalAmount": -1}},  # Sorting by total amount in descending order
#             {"$limit": 10}  # Limiting to top 10
#         ]

#         # Execute the aggregation payout_pipeline
#         payouts_top_10_merchants = list(FundTransfers.objects.aggregate(*payout_pipeline))
#         payoutsTop10MerchantsList = []
#         for each_payout_merchant in payouts_top_10_merchants:
#             payout_merchant_queryset = Users.objects(id=each_payout_merchant.get("_id")).first()

#             first_chars = re.findall(r'\b\w', payout_merchant_queryset.fullName)

#             imageString = ''.join(first_chars)

#             payOutDict = {
#             "merchantId":str(payout_merchant_queryset.id),
#             "merchantName":payout_merchant_queryset.fullName,
#             "phoneNumber":payout_merchant_queryset.phoneNumber,
#             "imageString":imageString,
#             "totalMerchantAmount":formatINR("{:.2f}".format(float(each_payout_merchant.get("totalAmount"))))
#             }
#             payoutsTop10MerchantsList.append(payOutDict)

#         data_status["responseStatus"]=1
#         data_status["result"]="Dashboard data fetched successfully!"
#         data_status["payInTop10MerchantsList"]=payInTop10MerchantsList
#         data_status["payoutsTop10MerchantsList"]=payoutsTop10MerchantsList
#         return data_status
#     except Exception as e:
#         app.logger.error(traceback.format_exc())
#         data_status["result"]="Unable to fetched dashboard data!!"
#         data_status["payInTop10MerchantsList"]=[]
#         data_status["payoutsTop10MerchantsList"]=[]
#         return data_status


# @admin.route("/dashboard_commissions_data",methods=["POST","GET"])
# def dashboard_commissions_data():
#     data_status = {"responseStatus":0,"result":""}
#     try:
#         if not session.get("adminId"):
#             data_status['responseStatus']=2
#             return data_status
#         commissionsDict = {}
#         payinTotalchargeAmount = 0
#         payinTotaltdsAmount = 0
#         payinTotalgstAmount = 0
#         totalPayinAmount = 0
#         payoutTotalchargeAmount = 0
#         payoutTotaltdsAmount = 0
#         payoutTotalgstAmount = 0
#         totalPayoutAmount = 0

#         payinTotalchargeAmount = WalletTransactions.objects(status=1).sum('commissionCharges.chargeAmount')
#         payinTotaltdsAmount = WalletTransactions.objects(status=1).sum('commissionCharges.tdsAmount')
#         payinTotalgstAmount = WalletTransactions.objects(status=1).sum('commissionCharges.gstAmount')

#         totalPayinAmount  = payinTotalchargeAmount + payinTotaltdsAmount + payinTotalgstAmount

#         print(totalPayinAmount,"totalPayinAmount Commissions")
        
#         payoutTotalchargeAmount = FundTransfers.objects(status=1).sum('commissionCharges.chargeAmount')
#         payoutTotaltdsAmount = FundTransfers.objects(status=1).sum('commissionCharges.tdsAmount')
#         payoutTotalgstAmount = FundTransfers.objects(status=1).sum('commissionCharges.gstAmount')

#         totalPayoutAmount  = payoutTotalchargeAmount + payoutTotaltdsAmount + payoutTotalgstAmount

#         print(totalPayoutAmount,"totalPayoutAmount Commissions")
        
#         commissionsDict = {
#         "totalPayinCommissionsAmount":formatINR("{:.2f}".format(float(payinTotalchargeAmount))),
#         "totalPayinTdsAmount":formatINR("{:.2f}".format(float(payinTotaltdsAmount))),
#         "totalPayinGstAmount":formatINR("{:.2f}".format(float(payinTotalgstAmount))),
#         "totalPayoutCommissionsAmount":formatINR("{:.2f}".format(float(payoutTotalchargeAmount))),
#         "totalPayoutTdsAmount":formatINR("{:.2f}".format(float(payoutTotaltdsAmount))),
#         "totalPayoutGstAmount":formatINR("{:.2f}".format(float(payoutTotalgstAmount))),
#         "totalPayoutAmount":formatINR("{:.2f}".format(float(totalPayoutAmount))),
#         "totalPayinAmount":formatINR("{:.2f}".format(float(totalPayinAmount))),
#         }

#         data_status["responseStatus"]=1
#         data_status["result"]="Commissions data fetched successfully!"
#         data_status["commissionsDict"]=commissionsDict
#         return data_status
#     except Exception as e:
#         app.logger.error(traceback.format_exc())
#         data_status["result"]="Unable to fetched commissions data!!"
#         data_status["commissionsDict"]={}
#         return data_status