from appservices.common.util import *
from appservices.common.form_schemas import *

user_commissions = Blueprint("user_commissions",__name__)


@user_commissions.route("/add_commission",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def add_commission():
    try:
        if not session.get("adminId"):
            return redirect("admin_login")
        adminId = session.get("adminId")
        csrf_token = request.form.get("csrf_token")
        print(csrf_token,"((((((((((((((csrf_token))))))))))))))")

        latitude = request.form.get("latitude", "")
        longitude = request.form.get("longitude", "")
        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

        actionDate=datetime.datetime.now()
        permissionsList = check_permissions(adminId,"userCommissionsListPermissions")
        if "add" in permissionsList:
            if request.method == "GET":
                operatorsList = []
                transactionAPIsList = []
                usersList = []

                operators_queryset = Operators.objects(status=1).order_by('-id').all()
                for each_operator in operators_queryset:
                    operator_dict = fetching_operator_details(each_operator)
                    operatorsList.append(operator_dict)

                # users_queryset = Users.objects(status__in=[0,1]).order_by("-id").all()
                # for each_user in users_queryset:
                # userTypeDict = fetching_user_type_details(each_user_type)
                # userTypesList.append(userTypeDict)
                # user_types_queryset = UserTypes.objects(isSuperDistributor=True,status__in=[0,1]).order_by("-id").all()
                # for each_user_type in user_types_queryset:
                users_queryset = Users.objects(status=1).order_by("-id").all()
                for each_user in users_queryset:
                    userDict = {
                    "userId":str(each_user.id),
                    "fullName":each_user.fullName
                    }
                    usersList.append(userDict)
                transaction_API_queryset = TransactionAPI.objects(status=1).order_by('-id').all()
                for each_transaction_api in transaction_API_queryset:
                    transactionAPIDict = {
                    "id":str(each_transaction_api.id),
                    "apiName":each_transaction_api.apiName
                    }
                    transactionAPIsList.append(transactionAPIDict)
                return render_template("super_admin_templates/add_commission.html",
                    operatorsList=operatorsList,transactionAPIsList=transactionAPIsList,usersList=usersList
                    )
            if request.method == "POST":
                commissionName = request.form.get("commissionName","")
                createdBy = request.form.get("createdBy","")
                operatorslist = request.form.getlist("operatorslist[]")
                chargeType = request.form.getlist("chargeType[]")
                chargeValue = request.form.getlist("chargeValue[]")
                commissionType = request.form.getlist("commissionType[]")
                commissionValue = request.form.getlist("commissionValue[]")
                transactionAPIId = request.form.getlist("transactionAPIId[]")

                jsonData = request.form.to_dict(flat=True)
                requestData = [jsonData]
                updatedrequestData = [jsonData]

                commissionLists = []
                for i in range(len(operatorslist)):
                    operator_queryset = Operators.objects(id=operatorslist[i]).first()
                    serviceId = str(operator_queryset.serviceId.id)
                    commissionDict = {
                        "operatorId": operatorslist[i],
                        "transactionAPIId": transactionAPIId[i],
                        "chargeType": chargeType[i],
                        "chargeValue": chargeValue[i],
                        "commissionType": commissionType[i],
                        "commissionValue": commissionValue[i],
                        "serviceId":serviceId
                    }
                    commissionLists.append(commissionDict)

                if commissionName:
                    try:
                        admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                        if admin_queryset:
                            message=admin_queryset.userName+" "+commissionName+" User commission created successfully!"
                            save_admin_log_table = save_admin_logs_data(adminId,None,None,"add_commission","create",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 
                        user_commission_table = Commissions(
                            adminId=adminId,
                            commissionName = commissionName,
                            commissionList = commissionLists,
                            userType = "admin",
                            # createdBy = createdBy,
                            createdOn = datetime.datetime.now(),
                            status = 1,
                            )
                        save_table = user_commission_table.save()
                        if createdBy == "":
                            save_table.update(createdBy=None)
                        else:
                            save_table.update(createdBy=ObjectId(createdBy))
                        flash("User commission added successfully!")
                        return redirect(url_for("user_commissions.user_commissions_list",redirectTo="Commission"))
                    except Exception as e:
                        flash("Unable to add user commission!!")
                        app.logger.error(traceback.format_exc())
                        return redirect(url_for("user_commissions.user_commissions_list",redirectTo="Commission"))
                else:
                    flash("Required fields are missing!!")
                    return redirect(url_for("user_commissions.user_commissions_list",redirectTo="Commission"))
        else:
            flash("The staff member does not have permission to create a User commission.", "danger")
            return redirect(url_for("user_commissions.user_commissions_list",redirectTo="Commission"))
    except Exception as e:
        app.logger.error(traceback.format_exc())
        error = "Unable to add user commission!!"
        return render_template("super_admin_templates/user_commissions_list.html",error=error)

# def fetching_user_commission_details(commission_queryset):
#   commissionDict = {}
#   try:
#       commissionDict = {
#       "id":str(commission_queryset.id),
#       # "commissionName":commission_queryset.commissionName,
#       "commissionList":commission_queryset.commissionList
#       }
#       # key_value_pairs = [(key, value) for each_commission_dict in commissionDict["commissionList"] for key, value in each_commission_dict.items()]
#       operator_ids = [each_commission_dict["operatorId"] for each_commission_dict in commissionDict["commissionList"]]
#       transaction_api_ids = [each_commission_dict["transactionAPIId"] for each_commission_dict in commissionDict["commissionList"]]
#       # if commission_queryset.createdBy:
#       #   commissionDict["createdBy"] = str(commission_queryset.createdBy.id)
#       #   commissionDict["createdByName"] = commission_queryset.createdBy.fullName
#       # else:
#       #   commissionDict["createdBy"] = ""
#       #   commissionDict["createdByName"] = "All"
#       if commission_queryset.status==1:
#           commissionDict["actionText"] = "Active"
#       else:
#           commissionDict["actionText"] = "Deactive"
#   except Exception as e:
#       app.logger.error(traceback.format_exc())
#   return commissionDict

def fetching_user_commission_details(commission_queryset):
    commissionDict = {}
    try:
        commissionDict = {
        "id":str(commission_queryset.id),
        "commissionList":commission_queryset.commissionList
        }
        # operator_ids = [each_commission_dict["operatorId"] for each_commission_dict in commissionDict["commissionList"]]
        # transaction_api_ids = [each_commission_dict["transactionAPIId"] for each_commission_dict in commissionDict["commissionList"]]
        # print(operator_ids,"(((((((((((((((operator_ids)))))))))))))))")
        merchantCommissionsList = []
        for each_commission in commission_queryset.commissionList:
            operator_queryset = Operators.objects(id=each_commission.get("operatorId")).first()
            if operator_queryset:
                operatorName=operator_queryset.operatorName
            else:
                operatorName=""
            each_commission_dict = {
            "operatorId":each_commission.get("operatorId"),
            "operatorName":operatorName,
            "commissionType":each_commission.get("commissionType"),
            "commissionValue":each_commission.get("commissionValue"),
            "chargeType":each_commission.get("chargeType"),
            "chargeValue":each_commission.get("chargeValue"),
            }
            merchantCommissionsList.append(each_commission_dict)
        # print(merchantCommissionsList,"(((((((((((((((merchantCommissionsList)))))))))))))))")
        commissionDict["merchantCommissionsList"]=merchantCommissionsList
        if commission_queryset.status==1:
            commissionDict["actionText"] = "Active"
        else:
            commissionDict["actionText"] = "Deactive"
    except Exception as e:
        app.logger.error(traceback.format_exc())
    return commissionDict


@user_commissions.route("/user_commissions_list",methods=["POST","GET"])
@adminid_access_token_required
def user_commissions_list():
    if not session.get("adminId"):
        return redirect("admin_login")
    commissionList = []
    categoriesList = []
    apiList = []
    pagination = None
    servicesList = []
    subServicesList = []
    operatorsList = []
    profilesList = []
    snoCount=0
    per_page = ""
    page=1

    form = SearchUserCommissionsList(request.args)
    
    adminId = session.get("adminId")
    
    permissionsList = check_permissions(session.get("adminId"),"userCommissionsListPermissions")
    # print(permissionsList,"((((((((permissionsList))))))))")
    if "view" in permissionsList:
        try:
            redirectTo = request.args.get("redirectTo","Commission")
            if redirectTo:
                redirectval = redirectTo
            else:
                redirectval = "Commission"
                

            categoryId = request.args.get("categoryId","")
            serviceId = request.args.get("serviceId","")
            subServiceId = request.args.get("subServiceId","")
            paymentGatewayId = request.args.get("paymentGatewayId","")
            profileId = request.args.get("profileId","")
            
            if request.method == "GET":   
                categories_queryset = ServiceGrouping.objects(status=1).only("id","name").order_by('-id')
                for each_category in categories_queryset:
                    category_dict = fetching_service_grouping_details(each_category)
                    categoriesList.append(category_dict)

                apis_queryset = TransactionAPI.objects(transactionType="Service",status=1).only("id","apiName").order_by("-id")
                for each_api in apis_queryset:
                    api_dict = fetching_transaction_api_details(each_api)
                    apiList.append(api_dict)

                profiles_queryset = Patterns.objects(status=1).order_by("-id")
                for each_profile in profiles_queryset:
                    profile_dict = fetching_pattern_details(each_profile)
                    profilesList.append(profile_dict)
                
                categories_queryset = Categories.objects(status=1).only("id","categoryName").order_by("-id")
                for each_category in categories_queryset:
                    category_dict = fetching_category_details(each_category)
                    servicesList.append(category_dict)
                
                services_queryset = Service.objects(status=1).only("id","serviceName").order_by("-id")
                for each_service in services_queryset:
                    service_dict = fetching_service_details(each_service)
                    subServicesList.append(service_dict)
            
            if form.validate():
                page = request.args.get(get_page_parameter(), type=int, default=1)
                per_page = 20 
                start = (page - 1) * per_page
                snoCount = start
                query=Q(status__in=[0,1])
                print("(((((((((((((((((((((((((perpage)))))))))))))))))))))))))",per_page)
                if categoryId and serviceId and subServiceId and paymentGatewayId and profileId:

                    services_queryset = Categories.objects(serviceGroupingId=categoryId,status=1).only("id","categoryName").order_by("-id")
                    for each_service in services_queryset:
                        serviceDict = {
                        "id":str(each_service.id),
                        "serviceName":each_service.categoryName
                        }
                        servicesList.append(serviceDict)
                    # if categoryId:
                    #     query &= Q(categoryName__in=[categoryId])

                    sub_services_queryset = Service.objects(categoryId=serviceId,status=1).only("id","serviceName").order_by("-id")
                    for each_sub_service in sub_services_queryset:
                        subServiceDict = {
                        "id":str(each_sub_service.id),
                        "subServiceName":each_sub_service.serviceName
                        }
                        subServicesList.append(subServiceDict)
                    # if serviceId:
                    #      query &= Q(serviceName__in=[serviceId])
                        
                    operators_queryset = Operators.objects(serviceGroupingId=categoryId,serviceId=subServiceId,transactionAPIId=paymentGatewayId).limit(per_page).skip(start).order_by("-id")
                    # print(operators_queryset.count(),"Operators COUNT")
                    for each_operator in operators_queryset:
                        operators_commission_queryset = Commissions.objects(
                            paymentGatewayId=paymentGatewayId,
                            subServiceId=subServiceId,
                            profileId=profileId,
                            commissionList__operatorId=str(each_operator.id)
                            ).first()
                        # print(operators_commission_queryset.commissionList,"operators_commission_queryset")
                        matched_commission_index=None
                        commissionoperatorDict={}
                        commissionValue="0"
                        chargeValue="0"
                        chargeType="FLAT"
                        commissionType="FLAT"
                        if operators_commission_queryset:
                            matched_commission_index = next((index for index, commission in enumerate(operators_commission_queryset.commissionList) if commission['operatorId'] == str(each_operator.id)), None)
                            print(matched_commission_index,"working")
                        else:
                            matched_commission_index = None
                        if matched_commission_index!=None:
                            commissionoperatorDict=operators_commission_queryset.commissionList[matched_commission_index]
                            print(commissionoperatorDict,"commissionoperatorDict")
                            print(each_operator.operatorName,"each_operator.operatorName")
                            commissionType=commissionoperatorDict.get('commissionType')
                            chargeType=commissionoperatorDict.get('chargeType')
                            chargeValue=commissionoperatorDict.get('chargeValue')
                            commissionValue=commissionoperatorDict.get('commissionValue')

                        operator_dict = {
                        "id":str(each_operator.id),
                        "operatorName":each_operator.operatorName,
                        "chargeType":chargeType,
                        "chargeValue":chargeValue,
                        "commissionType":commissionType,
                        "commissionValue":commissionValue,
                        }
                        operatorsList.append(operator_dict)
                    total_count =  Operators.objects(serviceGroupingId=categoryId,serviceId=subServiceId,transactionAPIId=paymentGatewayId).count()
                    print("(((((((((((((((((((((((total_count)))))))))))))))))))))))",total_count)
                    commissions_queryset = Commissions.objects(query).order_by("-id").all()
                    print("(((((((((((operators_queryset)))))))))))",len(operators_queryset))
                    for each_user_commission in commissions_queryset:
                        commissionDict = fetching_user_commission_details(each_user_commission)
                        commissionList.append(commissionDict)
                    print("((((((((((((((((((((((((pagenumber))))))))))))))))))))))))",page)
                    pagination = Pagination(page=page, total=total_count, per_page=per_page, alignment="right", record_name="Commissions")
            else:
                print("form errors",form.errors)

            return render_template("super_admin_templates/user_commissions_list.html",
                categoryId=categoryId,
                serviceId=serviceId,
                subServiceId=subServiceId,
                paymentGatewayId=paymentGatewayId,
                profileId=profileId,
                commissionList=commissionList,
                categoriesList=categoriesList,
                apiList=apiList,
                servicesList=servicesList,
                subServicesList=subServicesList,
                operatorsList=operatorsList,
                profilesList=profilesList,
                redirectval=redirectval,
                snoCount=snoCount,
                pagination=pagination,
                form=form,
                page=page
                )
        except Exception as e:
            app.logger.error(traceback.format_exc())
            error = "Unable to fetch user commissions details!!"
            return render_template("super_admin_templates/user_commissions_list.html", 
                error=error,
                categoryId=categoryId,
                serviceId=serviceId,
                subServiceId=subServiceId,
                paymentGatewayId=paymentGatewayId,
                profileId=profileId,
                categoriesList=categoriesList,
                commissionList=commissionList,
                apiList=apiList,
                servicesList=servicesList,
                subServicesList=subServicesList,
                operatorsList=operatorsList,
                profilesList=profilesList,
                redirectval=redirectval,
                snoCount=snoCount,
                pagination=pagination,
                form = form,
                page=page
                )
    else:
        flash("The staff member does not have permission to view User commissions.", "danger")
        return redirect(url_for("admin.dashboard"))



@user_commissions.route("/update_user_commission",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def update_user_commission():
    if not session.get("adminId"):
        return redirect("admin_login")
    adminId=session.get("adminId")  
    csrf_token = request.form.get("csrf_token")
    print(csrf_token,"((((((((((((((csrf_token))))))))))))))")  
    latitude = request.form.get("latitude", "")
    longitude = request.form.get("longitude", "")
    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()
    permissionsList = check_permissions(session.get("adminId"),"userCommissionsListPermissions")
    if "edit" in permissionsList:
        try:
            commissionId = request.args.get("commissionId","")
            if request.method == "GET":
                commission_queryset = Commissions.objects(id=commissionId).first()
                commissionDict = fetching_user_commission_details(commission_queryset)

                transactionAPIsList = []
                usersList = []

                operators_queryset = Operators.objects(status__in=[0,1]).order_by('-id').all()
                

                transaction_API_queryset = TransactionAPI.objects(status__in=[0,1]).order_by('-id').all()
                for each_transaction_api in transaction_API_queryset:
                    transactionAPIDict = {
                    "id":str(each_transaction_api.id),
                    "apiName":each_transaction_api.apiName
                    }
                    operatorsList = []
                    for each_operator in operators_queryset:
                        operator_dict = fetching_operator_details(each_operator)
                        checkcomm=0
                        chargeType=''
                        chargeValue=''
                        commissionType=''
                        commissionValue=''
                        for each_commission in commissionDict.get("commissionList"):
                            if str(each_operator.id) == each_commission["operatorId"] and each_commission["transactionAPIId"] == str(each_transaction_api.id):
                                checkcomm=1
                                chargeType=each_commission["chargeType"]
                                chargeValue=each_commission["chargeValue"]
                                commissionType=each_commission["commissionType"]
                                commissionValue=each_commission["commissionValue"]
                        if checkcomm==1:
                            operator_dict['chargeType']=chargeType
                            operator_dict['chargeValue']=chargeValue
                            operator_dict['commissionType']=commissionType
                            operator_dict['commissionValue']=commissionValue
                        else:
                            operator_dict['chargeType']=''
                            operator_dict['chargeValue']=''
                            operator_dict['commissionType']=''
                            operator_dict['commissionValue']=''
                        operatorsList.append(operator_dict)
                    transactionAPIDict['operatorsList']=operatorsList
                    transactionAPIsList.append(transactionAPIDict)
                users_queryset = Users.objects(status__in=[0,1]).order_by("-id").all()
                for each_user in users_queryset:
                    userDict = {
                    "userId":str(each_user.id),
                    "fullName":each_user.fullName
                    }
                    usersList.append(userDict)

               
                return render_template("super_admin_templates/user_commission_update.html",operatorsList=operatorsList,
                    transactionAPIsList=transactionAPIsList,commissionDict=commissionDict,usersList=usersList
                    )
            if request.method == "POST":
                commissionName = request.form.get("commissionName","")
                createdBy = request.form.get("createdBy","")
                operatorslist = request.form.getlist("operatorslist[]")
                chargeType = request.form.getlist("chargeType[]")
                chargeValue = request.form.getlist("chargeValue[]")
                commissionType = request.form.getlist("commissionType[]")
                commissionValue = request.form.getlist("commissionValue[]")
                transactionAPIId = request.form.getlist("transactionAPIId[]")
                jsonData = request.form.to_dict(flat=True)

                commission_queryset = Commissions.objects(id=commissionId).first()
                existing_record = commission_queryset.to_json()
                message=commission_queryset.adminId.userName+" "+commissionName+" User commission updated successfully!"
                requestData=[existing_record]
                updatedrequestData=[jsonData]
                save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_user_commission","update",actionDate,client_ip,browser,message,requestData,updatedrequestData) 

                if commission_queryset:
                    updateCommissionList = []
                    # exisitingList = commission_queryset.commissionList
                    # exisitingList.clear()
                    for i in range(len(operatorslist)):
                        operator_queryset = Operators.objects(id=operatorslist[i]).first()
                        serviceId = str(operator_queryset.serviceId.id)
                        commissionDict1 = {
                            "operatorId": operatorslist[i],
                            "chargeType": chargeType[i],
                            "chargeValue": chargeValue[i],
                            "commissionType": commissionType[i],
                            "commissionValue": commissionValue[i],
                            "transactionAPIId": transactionAPIId[i],
                            "serviceId":serviceId
                        }
                        updateCommissionList.append(commissionDict1)
                    commission_queryset.update(
                        commissionName=commissionName,
                        commissionList = updateCommissionList
                        )
                    if createdBy == "":
                        commission_queryset.update(createdBy=None)
                    else:
                        commission_queryset.update(createdBy=ObjectId(createdBy))
                    flash("User commission updated successfully!")
                    return redirect(url_for("user_commissions.user_commissions_list",redirectTo="Commission"))
                else:
                    flash("Invaild id!!")
                    return redirect(url_for("user_commissions.user_commissions_list",redirectTo="Commission"))
        except Exception as e:
            app.logger.error(traceback.format_exc())
            error = "Unable to update user commission!!"
            return redirect(url_for("user_commissions.user_commissions_list",redirectTo="Commission"))
    else:
        flash("The staff member does not have permission to update User commission.", "danger")
        return redirect(url_for("user_commissions.user_commissions_list",redirectTo="Commission"))


@user_commissions.route("/update_user_commission_status",methods=["POST","GET"])
@adminid_access_token_required
def update_user_commission_status():
    if not session.get("adminId"):
        return redirect("admin_login")
    adminId=session.get("adminId")
    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

    actionDate=datetime.datetime.now()

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

    existing_record = ""
    updatedrequestData = [jsonData]
    permissionsList = check_permissions(session.get("adminId"),"userCommissionsListPermissions")
    if "edit" in permissionsList:
        commissionId = request.args.get("commissionId","")

        if commissionId:
            try:
                commission_queryset = Commissions.objects(id=commissionId,status__in=[0,1]).first()
                existing_record = commission_queryset.to_json()
                requestData = [existing_record]
                if commission_queryset:
                    if commission_queryset.status == 0:
                        commission_queryset.update(status=1)
                        flash("User commission activated successfully!")
                        message=commission_queryset.adminId.userName+" "+commission_queryset.commissionName+" User commission activated successfully!"
                    elif commission_queryset.status == 1:
                        commission_queryset.update(status=0)
                        flash("User commission deactivated successfully!")
                        message=commission_queryset.adminId.userName+" "+commission_queryset.commissionName+" User commission deactivated successfully!"
                    save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_user_commission_status","updatestatus",actionDate,client_ip,browser,message,requestData,updatedrequestData)
                    return redirect(url_for("user_commissions.user_commissions_list",redirectTo="Commission"))
                else:
                    flash("Invaild id!!")
                    return redirect(url_for("user_commissions.user_commissions_list",redirectTo="Commission"))
            except Exception as e:
                app.logger.error(traceback.format_exc())
                return redirect(url_for("user_commissions.user_commissions_list",redirectTo="Commission"))
        else:
            return redirect(url_for("user_commissions.user_commissions_list"))
    else:
        flash("The staff member does not have permission to update User commission status.", "danger")
        return redirect(url_for("user_commissions.user_commissions_list",redirectTo="Commission"))


@user_commissions.route("/get_user_commission_details",methods=["POST"])
@adminid_access_token_required
@csrf.exempt
def get_user_commission_details():
    data_status = {"responseStatus": 0, "result": ""}
    userId = request.form.get("userId","")

    if not userId:
        data_status["result"]="Required fields are missing!!"
        return data_status
    commissionList=[]
    try:
        user_queryset = Users.objects(id=userId).order_by("-id").first()
        if not user_queryset:
            data_status["result"]="Invaild user id!!"
            return data_status

        commissionId = str(user_queryset.commissionId.id)
        commission_queryset = Commissions.objects(id=commissionId,status__in=[1]).order_by("-id").first()

        commissionDict = {
        "id":str(commission_queryset.id),
        "commissionName":commission_queryset.commissionName,
        "userType":commission_queryset.userType,
        "commissionList":commission_queryset.commissionList
        }
        data_status["responseStatus"] = 1
        data_status["result"] = "Commission data fected successfull!"
        data_status["commissionDict"] = commissionDict
        return data_status
    except Exception as e:
        app.logger.error(traceback.format_exc())
        data_status["result"]="Unable to fetch commission data!!"
        return data_status

@user_commissions.route("/get_category_based_on_services",methods=["POST"])
@adminid_access_token_required
@csrf.exempt
def get_category_based_on_services():
    data_status = {"responseStatus": 0, "result": ""}
    categoryId = request.form.get("categoryId","")

    if not categoryId:
        data_status["result"]="Required fields are missing!!"
        return data_status

    servicesList=[]
    try:
        category_queryset = ServiceGrouping.objects(id=categoryId,status=1).order_by('-id').first()
        if not category_queryset:
            data_status["result"]="Invaild category id!!"
            return data_status

        services_queryset = Categories.objects(serviceGroupingId=str(category_queryset.id)).order_by("-id")
        for each_service in services_queryset:
            serviceDict = {
            "id":str(each_service.id),
            "serviceName":each_service.categoryName
            }
            servicesList.append(serviceDict)

        data_status["responseStatus"] = 1
        data_status["result"] = "Category based services data fected successfully!"
        data_status["servicesList"] = servicesList
        return data_status
    except Exception as e:
        app.logger.error(traceback.format_exc())
        data_status["result"]="Unable to fetch services data!!"
        return data_status

@user_commissions.route("/get_service_based_on_subservices",methods=["POST"])
@adminid_access_token_required
@csrf.exempt
def get_service_based_on_subservices():
    data_status = {"responseStatus": 0, "result": ""}
    serviceId = request.form.get("serviceId","")

    if not serviceId:
        data_status["result"]="Required fields are missing!!"
        return data_status

    subServicesList=[]
    try:
        service_queryset = Categories.objects(id=serviceId,status=1).order_by('-id').first()
        if not service_queryset:
            data_status["result"]="Invaild service id!!"
            return data_status

        sub_services_queryset = Service.objects(categoryId=str(service_queryset.id)).order_by("-id")
        for each_sub_service in sub_services_queryset:
            subServiceDict = {
            "id":str(each_sub_service.id),
            "subServiceName":each_sub_service.serviceName
            }
            subServicesList.append(subServiceDict)
        data_status["responseStatus"] = 1
        data_status["result"] = "Service based sub services data fected successfully!"
        data_status["subServicesList"] = subServicesList
        return data_status
    except Exception as e:
        app.logger.error(traceback.format_exc())
        data_status["result"]="Unable to fetch sub services data!!"
        return data_status


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

        adminId = session.get("adminId")
        csrf_token = request.form.get("csrf_token")
        print(csrf_token,"((((((((((((((csrf_token))))))))))))))")
        latitude = request.form.get("latitude", "")
        longitude = request.form.get("longitude", "")
        loginBrowser = request.headers.get("Sec-Ch-Ua")
        page = int(request.form.get("page",1))
        print("((((((((((((page))))))))))))", page)
        
        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()
        if request.method == "GET":
            operatorsList = []
            transactionAPIsList = []
            usersList = []
        
        if request.method == "POST":
            operatorslist = request.form.getlist("operatorslist[]")
            chargeType = request.form.getlist("chargeType[]")
            chargeValue = request.form.getlist("chargeValue[]")
            commissionType = request.form.getlist("commissionType[]")
            commissionValue = request.form.getlist("commissionValue[]")
            categoryId = request.form.get("categoryId", "")
            serviceId = request.form.get("serviceId", "")
            subServiceId = request.form.get("subServiceId", "")
            paymentGatewayId = request.form.get("paymentGatewayId", "")
            profileId = request.form.get("profileId", "")
            jsonData = request.form.to_dict(flat=True)
            requestData = [jsonData]
            updatedrequestData = [jsonData]
            commissionLists = []
            for i in range(len(operatorslist)):
                commissionDict = {
                    "operatorId": operatorslist[i],
                    "transactionAPIId": paymentGatewayId,
                    "chargeType": chargeType[i],
                    "chargeValue": chargeValue[i],
                    "commissionType": commissionType[i],
                    "commissionValue": commissionValue[i],
                    "serviceGroupingId": categoryId,
                    "categoryId": serviceId,
                    "serviceId": subServiceId,
                    "profileId": profileId
                }
                commissionLists.append(commissionDict)

            try:
                admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                if admin_queryset:
                    message=admin_queryset.userName+" Merchant commission updated successfully!"
                    save_admin_log_table = save_admin_logs_data(adminId,None,None,"create_commission","create",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 
                # Check if a commission record already exists for the profile and service
                user_commission_queryset = Commissions.objects(profileId=profileId, paymentGatewayId=paymentGatewayId, subServiceId=subServiceId).first()

                if user_commission_queryset:
                    # If a record exists, update the commission list and any other relevant fields
                    user_commission_queryset.update(commissionList=commissionLists)
                    flash("Merchant commission updated successfully!")
                else:
                    # If no record exists, create a new commission record
                    user_commission_table = Commissions(
                        adminId=adminId,
                        profileId=profileId,
                        paymentGatewayId=paymentGatewayId,
                        subServiceId=subServiceId,
                        commissionList=commissionLists,
                        createdOn=datetime.datetime.now(),
                        status=1
                    )
                    user_commission_table.save()
                    flash("Merchant commission created successfully!")

                return redirect(url_for("user_commissions.user_commissions_list",categoryId=categoryId,serviceId=serviceId,subServiceId=subServiceId,profileId=profileId,paymentGatewayId=paymentGatewayId,page=page,redirectTo='page'))

            except Exception as e:
                flash("Unable to create or update merchant commission!")
                app.logger.error(traceback.format_exc())
                return redirect(url_for("user_commissions.user_commissions_list",categoryId=categoryId,serviceId=serviceId,subServiceId=subServiceId,profileId=profileId,paymentGatewayId=paymentGatewayId,page=page,redirectTo='page'))

    except Exception as e:
        app.logger.error(traceback.format_exc())
        error = "Unable to create or update merchant commission!"
        return render_template("super_admin_templates/user_commissions_list.html", error=error,page=page)




