from appservices.common.util import *
from appservices.common.form_schemas import *
patterns_configuarations = Blueprint("patterns_configuarations",__name__)
from wtforms import BooleanField, FieldList, FormField, StringField
from wtforms import StringField, BooleanField, SelectField, FieldList, FormField, TimeField,DateField
from flask_wtf import FlaskForm
from wtforms import StringField, IntegerField, SelectField, SelectMultipleField, BooleanField,RadioField
from wtforms.validators import DataRequired, Length, Regexp, NumberRange, Optional, ValidationError
import math

# class ProfileForm(FlaskForm):
#     name = StringField('', validators=[DataRequired(),Length(min=1, max=75),Regexp(r'^[a-zA-Z0-9\s@#$()+_\-/]+$', message="Only alphanumeric and special characters @#$()+_-/")])
#     rank = IntegerField('', validators=[DataRequired(),NumberRange(min=1, max=999999, message="Rank must be between 1 and 999999")])
#     description = StringField('', validators=[DataRequired(),Length(min=1, max=150)])
#     code = StringField('', validators=[DataRequired(),Length(min=1, max=150),Regexp(r'^[a-zA-Z0-9\s]+$', message="Code can only contain letters, numbers, and spaces.")])
#     userPermissionId = SelectField('', choices=[],validate_choice=False, validators=[DataRequired()])
#     payinPaymentGatewaysList = SelectMultipleField('', choices=[],validate_choice=False, validators=[Optional()])
#     defaultProfile = BooleanField('')
#     payinEnable = BooleanField('')
#     defaultPayinPaymentGatewayId = SelectField('', choices=[],validate_choice=False, validators=[Optional()])
#     payoutEnable = BooleanField('')
#     defaultPayoutPaymentGatewayId = SelectField('', choices=[],validate_choice=False, validators=[Optional()])
#     remark = StringField('', validators=[Length(max=255)])


#     def __init__(self, *args, current_id=None, **kwargs):
#         super().__init__(*args, **kwargs)
#         self.current_id = str(current_id) if current_id else None
#         if self.current_id:
#             self.remark.validators.append(DataRequired(message="Remark is required."))  # Make remark mandatory

#         if not self.current_id:
#             del self.remark
#         # self.process(*args, **kwargs)

#     def validate_defaultPayinPaymentGatewayId(self, field):
#         if self.payinEnable.data and not field.data:
#             raise ValidationError("Please select a Payin Payment Gateway.")

#     def validate_defaultPayoutPaymentGatewayId(self, field):
#         if self.payoutEnable.data and not field.data:
#             raise ValidationError("Please select a Payout Payment Gateway.")
# class UpdateStatusRemarkForm(FlaskForm):
#     remark = StringField('', validators=[DataRequired(),Length(min=1, max=150),Regexp(r'^[a-zA-Z0-9\s@#$()+_\-/]+$', message="Only alphanumeric and special characters @#$()+_-/")])
        

TIME_PATTERN = r"^(?:[01]\d|2[0-3]):[0-5]\d$"



# class TimeRangeForm(FlaskForm):
#     from_time = TimeField('', format="%H:%M", validators=[Optional(), Regexp(TIME_PATTERN, message="Enter time in 24-hour format (HH:MM)")])
#     to_time = TimeField("", format="%H:%M", validators=[Optional(), Regexp(TIME_PATTERN, message="Enter time in 24-hour format (HH:MM)")])


# class AvailableTimingsForm(FlaskForm):
#     transactionType = SelectField('', choices=[("payout", "Payout"), ("paymentgateway", "Payment Gateway")], validators=[Optional()])
#     siteId = SelectField('', choices=[], validate_choice=False, validators=[Optional()])
#     isEnabled = BooleanField("Enable All Timings")

#     # Days of the week
#     Sunday_is_enabled = BooleanField("Enable Sunday")
#     sunAvailableTimingsList = FieldList(FormField(TimeRangeForm))
#     # from_time_Sunday = TimeField('', format="%H:%M", validators=[Optional(), Regexp(TIME_PATTERN, message="Enter time in 24-hour format (HH:MM)")])
#     # to_time_Sunday = TimeField("", format="%H:%M", validators=[Optional(), Regexp(TIME_PATTERN, message="Enter time in 24-hour format (HH:MM)")])

#     Monday_is_enabled = BooleanField("Enable Monday")
#     # from_time_Monday = TimeField('', format="%H:%M", validators=[Optional(), Regexp(TIME_PATTERN, message="Enter time in 24-hour format (HH:MM)")])
#     # to_time_Monday = TimeField("", format="%H:%M", validators=[Optional(), Regexp(TIME_PATTERN, message="Enter time in 24-hour format (HH:MM)")])
#     monAvailableTimingsList = FieldList(FormField(TimeRangeForm))
    

#     Tuesday_is_enabled = BooleanField("Enable Tuesday")
#     # from_time_Tuesday = TimeField('', format="%H:%M", validators=[Optional(), Regexp(TIME_PATTERN, message="Enter time in 24-hour format (HH:MM)")])
#     # to_time_Tuesday = TimeField("", format="%H:%M", validators=[Optional(), Regexp(TIME_PATTERN, message="Enter time in 24-hour format (HH:MM)")])
#     tueAvailableTimingsList = FieldList(FormField(TimeRangeForm))
    

#     Wednesday_is_enabled = BooleanField("Enable Wednesday")
#     # from_time_Wednesday = TimeField('', format="%H:%M", validators=[Optional(), Regexp(TIME_PATTERN, message="Enter time in 24-hour format (HH:MM)")])
#     # to_time_Wednesday = TimeField("", format="%H:%M", validators=[Optional(), Regexp(TIME_PATTERN, message="Enter time in 24-hour format (HH:MM)")])
#     wedAvailableTimingsList = FieldList(FormField(TimeRangeForm))

#     Thursday_is_enabled = BooleanField("Enable Thursday")
#     # from_time_Thursday = TimeField('', format="%H:%M", validators=[Optional(), Regexp(TIME_PATTERN, message="Enter time in 24-hour format (HH:MM)")])
#     # to_time_Thursday = TimeField("", format="%H:%M", validators=[Optional(), Regexp(TIME_PATTERN, message="Enter time in 24-hour format (HH:MM)")])
#     thuAvailableTimingsList = FieldList(FormField(TimeRangeForm))

#     Friday_is_enabled = BooleanField("Enable Friday")
#     # from_time_Friday = TimeField('', format="%H:%M", validators=[Optional(), Regexp(TIME_PATTERN, message="Enter time in 24-hour format (HH:MM)")])
#     # to_time_Friday = TimeField("", format="%H:%M", validators=[Optional(), Regexp(TIME_PATTERN, message="Enter time in 24-hour format (HH:MM)")])
#     friAvailableTimingsList = FieldList(FormField(TimeRangeForm))

#     Saturday_is_enabled = BooleanField("Enable Saturday")
#     # from_time_Saturday = TimeField('', format="%H:%M", validators=[Optional(), Regexp(TIME_PATTERN, message="Enter time in 24-hour format (HH:MM)")])
#     # to_time_Saturday = TimeField("", format="%H:%M", validators=[Optional(), Regexp(TIME_PATTERN, message="Enter time in 24-hour format (HH:MM)")])
#     satAvailableTimingsList = FieldList(FormField(TimeRangeForm))

#     overridesDatesList = FieldList(StringField("Override Date", validators=[Optional()]))

#     def validate_siteId(self, field):
#         if field.data:
#             if not ObjectId.is_valid(field.data):
#                 raise ValidationError("Invalid Site Id.")
#             site_queryset = MultipleAppSites.objects(id=field.data, status__nin=[2]).first()
#             if not site_queryset:
#                 raise ValidationError("Please select a valid Site Id.")

#     def __init__(self, *args, current_id=None, **kwargs):
#         super().__init__(*args, **kwargs)
#         self.current_id = str(current_id) if current_id else None

        
#         for day in ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']:
#             for days in ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat']:
#                 day_enabled = getattr(self, f"{day}_is_enabled")
#                 print(day_enabled,"((((((((((((((((day_enabled))))))))))))))))")
#                 available_timings_list = getattr(self, f"{days.lower()}AvailableTimingsList")  # Correct field name
#                 print(available_timings_list,"((((((((((((((((day_enabled))))))))))))))))")
#                 if day_enabled.data:  # If the day is enabled, make the fields required
#                     day_enabled.validators = [v for v in day_enabled.validators if not isinstance(v, Optional)]  # Remove Optional
#                     day_enabled.validators.append(DataRequired())  # Add DataRequired

#                     # For each time slot of the day, make from_time and to_time required
#                     for timing_form in available_timings_list.entries:
#                         timing_form.from_time.validators = [v for v in timing_form.from_time.validators if not isinstance(v, Optional)]
#                         timing_form.from_time.validators.append(DataRequired(message=f"{day} From Time is required"))

#                         timing_form.to_time.validators = [v for v in timing_form.to_time.validators if not isinstance(v, Optional)]
#                         timing_form.to_time.validators.append(DataRequired(message=f"{day} To Time is required"))

class TimeRangeForm(FlaskForm):
    from_time = TimeField('', format="%H:%M", validators=[
        Optional(), Regexp(TIME_PATTERN, message="Enter time in 24-hour format (HH:MM)")])
    to_time = TimeField('', format="%H:%M", validators=[
        Optional(), Regexp(TIME_PATTERN, message="Enter time in 24-hour format (HH:MM)")])


class AvailableTimingsForm(FlaskForm):
    transactionType = SelectField('', choices=[
        ("payout", "Payout"), ("paymentgateway", "Payment Gateway")], validators=[Optional()])
    siteId = SelectField('', choices=[], validate_choice=False, validators=[Optional()])
    isEnabled = BooleanField("Enable All Timings")

    # Day-wise fields
    Sunday_is_enabled = BooleanField("Enable Sunday")
    sunAvailableTimingsList = FieldList(FormField(TimeRangeForm))

    Monday_is_enabled = BooleanField("Enable Monday")
    monAvailableTimingsList = FieldList(FormField(TimeRangeForm))

    Tuesday_is_enabled = BooleanField("Enable Tuesday")
    tueAvailableTimingsList = FieldList(FormField(TimeRangeForm))

    Wednesday_is_enabled = BooleanField("Enable Wednesday")
    wedAvailableTimingsList = FieldList(FormField(TimeRangeForm))

    Thursday_is_enabled = BooleanField("Enable Thursday")
    thuAvailableTimingsList = FieldList(FormField(TimeRangeForm))

    Friday_is_enabled = BooleanField("Enable Friday")
    friAvailableTimingsList = FieldList(FormField(TimeRangeForm))

    Saturday_is_enabled = BooleanField("Enable Saturday")
    satAvailableTimingsList = FieldList(FormField(TimeRangeForm))

    overridesDatesList = FieldList(StringField("Override Date", validators=[Optional()]))

    def validate_siteId(self, field):
        if field.data:
            if not ObjectId.is_valid(field.data):
                raise ValidationError("Invalid Site Id.")
            # You may need to import and query your DB correctly
            site_queryset = MultipleAppSites.objects(id=field.data, status__nin=[2]).first()
            if not site_queryset:
                raise ValidationError("Please select a valid Site Id.")

    def __init__(self, *args, current_id=None, **kwargs):
        super().__init__(*args, **kwargs)
        self.current_id = str(current_id) if current_id else None

        day_mapping = [
            ("Sunday", "sun"),
            ("Monday", "mon"),
            ("Tuesday", "tue"),
            ("Wednesday", "wed"),
            ("Thursday", "thu"),
            ("Friday", "fri"),
            ("Saturday", "sat"),
        ]

        # Check if global enable is checked
        all_enabled = self.isEnabled.data

        for full_day, short_day in day_mapping:
            day_enabled = getattr(self, f"{full_day}_is_enabled")
            timing_list = getattr(self, f"{short_day}AvailableTimingsList")

            # If all enabled or individual day is enabled
            if all_enabled or day_enabled.data:
                # Make checkbox required
                day_enabled.validators = [v for v in day_enabled.validators if not isinstance(v, Optional)]
                day_enabled.validators.append(DataRequired())

                for timing_form in timing_list.entries:
                    # from_time
                    timing_form.from_time.validators = [
                        v for v in timing_form.from_time.validators if not isinstance(v, Optional)
                    ]
                    timing_form.from_time.validators.append(
                        DataRequired(message=f"{full_day} From Time is required")
                    )

                    # to_time
                    timing_form.to_time.validators = [
                        v for v in timing_form.to_time.validators if not isinstance(v, Optional)
                    ]
                    timing_form.to_time.validators.append(
                        DataRequired(message=f"{full_day} To Time is required")
                    )

    
    





############### Patterns ################
def otpCommonHelper(action,requestData,adminId):
    data_status= {"responseStatus": 0, "result": ""}
    print(action,"((((((((((((((((action))))))))))))))))")
    if action == "generate":
        mail_type = requestData.get("mailType", "").strip()
        print(mail_type,"((((((((((((((((mail_type))))))))))))))))")
        if not mail_type:
            data_status["result"]= "mailType is required!"
            return data_status
        generateResponse = generate_otp_helper(mail_type)
        return generateResponse

    # tep 2: Handle OTP Verification
    elif action == "verify":
        otp_check_id = requestData.get("otpCheckId","")
        otp_code = requestData.get("otpCode","")

        print(otp_check_id,"((((((((OTP CHECK ID????????????))))))))")
        print(otp_code,"((((((((OTP CODE????????????))))))))")

        if not otp_check_id or not otp_code:
            data_status["result"]= "Required fields are missing!"
            return data_status

        verifyResponse = verify_otp_helper(otp_check_id, otp_code)
        return verifyResponse
    
    elif action == "update":
        otp_check_id = request.form.get("otpCheckId", "")
        
        otpcheck_queryset = OtpChecks.objects(adminId=adminId, id=str(otp_check_id), status=1).first()

        if not otpcheck_queryset:
            data_status["result"]= "Invalid Request."
            return data_status
        # Update OTP status to 2 after verification
        otpcheck_queryset.update(status=2)
        data_status["responseStatus"]= 1
        data_status["result"]= "OTP status successfully updated!"
        return data_status
    else:
        data_status["result"]= "Invalid Request."
        return data_status

@patterns_configuarations.route("/add_pattern",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def add_pattern():
    data_status={"responseStatus":0,"result":""}
    try:
        if not session.get("adminId"):
            flash("Session expired","warning")
            data_status["responseStatus"]=4
            return data_status
        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,"patternPermissions")
        if "add" in permissionsList:
            if request.method == "POST":
               
                action = request.form.get("action", "").strip()
                data = request.form.to_dict()
               
                
                otp_check_id = request.form.get("otpLogid", "")
                defaultVerificationId = request.form.get("defaultVerificationId", "")
                print("otp_check_id",otp_check_id)
                if not otp_check_id:
                    flash("Invalid Request.")
                    data_status["responseStatus"]=4
                    return data_status

                otpcheck_queryset = OtpChecks.objects(adminId=adminId,defaultVerificationField=defaultVerificationId, id=str(otp_check_id), status=1).first()

                if not otpcheck_queryset:
                    flash("Invalid Request.")
                    data_status["responseStatus"]=4
                    return data_status

                name = request.form.get("name","")
                rank = request.form.get("rank",0)
                description = request.form.get("description","")
                code = request.form.get("code","")
                isUserWise = request.form.get("isUserWise")
                isAllow = request.form.get("isAllow")
                isCommission = request.form.get("isCommission")
                isSuperDistributor = request.form.get("isSuperDistributor")
                userPermissionId = request.form.get("userPermissionId","")
                # payoutPaymentGatewayId = request.form.get("payoutPaymentGatewayId","")
                payinPaymentGatewaysList = request.form.getlist("payinPaymentGatewaysList")
                payinEnable = request.form.get("payinEnable")
                payoutEnable = request.form.get("payoutEnable")
                defaultProfile = request.form.get("defaultProfile")
                defaultPayinPaymentGatewayId = request.form.get("defaultPayinPaymentGatewayId")
                defaultPayoutPaymentGatewayId = request.form.get("defaultPayoutPaymentGatewayId")

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

                # if name and not is_valid_alphanumeric(name):
                #     flash("Pattern must contain only alphanumeric characters, spaces, and specific special characters: @#$()+_-/")
                #     return redirect(url_for("patterns_configuarations.get_patterns_configuarations_list"))

                # if description and not is_valid_description(description):
                #     flash("Description can contain all characters.")
                #     return redirect(url_for("patterns_configuarations.get_patterns_configuarations_list"))

                # if code and not is_valid_alphanumeric_without_specialCharacters(code):
                #     flash("code must contain only alphanumeric characters")
                #     return redirect(url_for("patterns_configuarations.get_patterns_configuarations_list"))
                form=ProfileForm()

                print("((((((((((((((((((form))))))))))))))))))",request.form)

                
                if form.validate_on_submit():

                    if name and rank and description and code and userPermissionId:
                        try:
                            admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                            if admin_queryset:
                                message=admin_queryset.userName+" "+name+" Profile created successfully!"
                                save_admin_log_table = save_admin_logs_data(adminId,None,None,"add_pattern","create",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 

                            if isUserWise == "True":
                                isUserWise=True
                            else:
                                isUserWise=False

                            if isAllow == "True":
                                isAllow=True
                            else:
                                isAllow=False

                            if isCommission == "True":
                                isCommission=True
                            else:
                                isCommission=False

                            if isSuperDistributor == "True":
                                isSuperDistributor=True
                            else:
                                isSuperDistributor=False

                            if payinPaymentGatewaysList:
                                payinPaymentGatewaysList=[ObjectId(each_payin_pg) for each_payin_pg in payinPaymentGatewaysList]
                            else:
                                payinPaymentGatewaysList = []

                            if payinEnable == "True":
                                payinEnable=True
                                defaultPayinPaymentGatewayId=ObjectId(defaultPayinPaymentGatewayId)
                            else:
                                payinEnable=False 
                                defaultPayinPaymentGatewayId=None

                            if payoutEnable == "True":
                                payoutEnable=True
                                if defaultPayoutPaymentGatewayId:
                                    payoutPaymentGatewayId=ObjectId(defaultPayoutPaymentGatewayId)
                                else:
                                    payoutPaymentGatewayId = None
                            else:
                                payoutEnable=False
                                payoutPaymentGatewayId = None

                            if defaultProfile == "True":
                                defaultProfile=True
                                profiles_queryset = Patterns.objects(status__in=[0,1])
                                profiles_queryset.update(defaultProfile=False)
                            else:
                                defaultProfile=False


                            patterns_table = Patterns(
                                adminId=adminId,
                                name = name,
                                rank = rank,
                                description = description,
                                code = code,
                                isUserWise = isUserWise,
                                isAllow = isAllow,
                                isCommission = isCommission,
                                isSuperDistributor = isSuperDistributor,
                                payinPaymentGatewaysList = payinPaymentGatewaysList,
                                payoutPaymentGatewayId = payoutPaymentGatewayId,
                                defaultPayinPaymentGatewayId = defaultPayinPaymentGatewayId,
                                payinEnable = payinEnable,
                                payoutEnable = payoutEnable,
                                defaultProfile = defaultProfile,
                                userPermissionId = userPermissionId,
                                createdOn = datetime.datetime.now(),
                                status = 1,
                                )
                            save_table = patterns_table.save()

                            flash("Profile has been saved successfully!", "success")
                            data_status["responseStatus"]=1
                            return data_status
                
                        except Exception as e:
                            flash("Unable to save profile details.", "error")
                            app.logger.error(traceback.format_exc())
                            data_status["responseStatus"]=4
                            return data_status
                    else:
                        flash("Required fields are missing!","warning")
                        data_status["responseStatus"]=2
                        return data_status
                else:
                    data_status['result']=form.errors
                    print("(((((((((((((((((((((((((((((((((((())))))))))))))))))))))))))))))))))))",form.errors)
                    return data_status


            else:
                flash("The request you made is invalid. Please check and try again.", "error")
                data_status["responseStatus"]=4
                return data_status

        else:
            flash("The staff member does not have permission to create a Pattern.", "danger")
            data_status["responseStatus"]=4
            return data_status
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("Unable to save pattern details.", "error")
        data_status["responseStatus"]=4
        return data_status


@patterns_configuarations.route("/update_pattern",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def update_pattern():
    data_status={"responseStatus":0,"result":""}
    if not session.get("adminId"):
        data_status["responseStatus"]=4
        return data_status
    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"),"patternPermissions")
    if "edit" in permissionsList:
        try:
            patternId = request.args.get("patternId","")
            if request.method == "POST":
                action = request.form.get("action", "").strip()
                data = request.form.to_dict()
                
                otp_check_id = request.form.get("otpLogid", "")
                defaultVerificationId = request.form.get("defaultVerificationId", "")
                print("otp_check_id",otp_check_id)
                if not otp_check_id:
                    flash("Invalid request.", "error")
                    data_status["responseStatus"]=4
                    return data_status

                otpcheck_queryset = OtpChecks.objects(adminId=adminId,defaultVerificationField=defaultVerificationId, id=str(otp_check_id), status=1).first()
                
                if not otpcheck_queryset:
                    flash("Invalid request.", "error")
                    data_status["responseStatus"]=4
                    return data_status
                # Update OTP status to 2 after verification
                otpcheck_queryset.update(status=2)
                # return jsonify({"responseStatus": 1, "result": "OTP status successfully updated!"})

                name = request.form.get("name","")
                rank = request.form.get("rank")
                description = request.form.get("description","")
                userPermissionId = request.form.get("userPermissionId","")
                code = request.form.get("code","")
                isUserWise = request.form.get("isUserWise")
                isAllow = request.form.get("isAllow")
                isCommission = request.form.get("isCommission")
                isSuperDistributor = request.form.get("isSuperDistributor")
                payoutPaymentGatewayId = request.form.get("payoutPaymentGatewayId")
                payinPaymentGatewaysList = request.form.getlist("payinPaymentGatewaysList")
                payinEnable = request.form.get("payinEnable")
                payoutEnable = request.form.get("payoutEnable")
                defaultProfile = request.form.get("defaultProfile")
                defaultPayinPaymentGatewayId = request.form.get("defaultPayinPaymentGatewayId")
                # defaultPayoutPaymentGatewayId = request.form.get("defaultPayoutPaymentGatewayId")
                jsonData = request.form.to_dict(flat=True)
                remark = request.form.get("remark","")


                form=ProfileForm(request.form,current_id=patternId)
                if form.validate_on_submit():
                # if name and not is_valid_alphanumeric(name):
                #     flash("Pattern must contain only alphanumeric characters, spaces, and specific special characters: @#$()+_-/")
                #     return redirect(url_for("patterns_configuarations.get_patterns_configuarations_list"))

                # if description and not is_valid_description(description):
                #     flash("Description can contain all characters.")
                #     return redirect(url_for("patterns_configuarations.get_patterns_configuarations_list"))

                # if code and not is_valid_alphanumeric_without_specialCharacters(code):
                #     flash("code must contain only alphanumeric characters")
                #     return redirect(url_for("patterns_configuarations.get_patterns_configuarations_list"))

                    if name and rank and description and code and userPermissionId:
                        pattern_queryset = Patterns.objects(id=patternId,status__in=[0,1]).first()
                        existing_record = pattern_queryset.to_json()
                        message=pattern_queryset.adminId.userName+" "+name+" Profile updated successfully!"
                        requestData=[existing_record]
                        updatedrequestData=[jsonData]
                        save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_pattern","update",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)
                        save_remarks_data=save_admin_remarks_data(patternId,adminId,remark,"Profile") 

                        if pattern_queryset:
                            if isUserWise == "True":
                                isUserWiseval=True
                            else:
                                isUserWiseval=False

                            if isAllow == "True":
                                isAllowval=True
                            else:
                                isAllowval=False

                            if isCommission == "True":
                                isCommissionval=True
                            else:
                                isCommissionval=False

                            if isSuperDistributor == "True":
                                isSuperDistributorval=True
                            else:
                                isSuperDistributorval=False

                            if payinEnable == "True":
                                payinEnable=True
                                defaultPayinPaymentGatewayId=ObjectId(defaultPayinPaymentGatewayId)
                            else:
                                payinEnable=False
                                defaultPayinPaymentGatewayId=None

                            if payoutEnable == "True":
                                payoutEnable=True
                                payoutPaymentGatewayId=ObjectId(payoutPaymentGatewayId)
                            else:
                                payoutEnable=False
                                payoutPaymentGatewayId=None

                            if defaultProfile == "True":
                                defaultProfile=True
                                profiles_queryset = Patterns.objects(status__in=[0,1])
                                profiles_queryset.update(defaultProfile=False)
                            else:
                                defaultProfile=False

                            pattern_queryset.update(
                                name = name,
                                rank = rank,
                                description = description,
                                isUserWise = isUserWiseval,
                                isAllow = isAllowval,
                                isCommission = isCommissionval,
                                isSuperDistributor = isSuperDistributorval,
                                userPermissionId = ObjectId(userPermissionId),
                                payinEnable = payinEnable,
                                payoutEnable = payoutEnable,
                                defaultProfile = defaultProfile,
                                payoutPaymentGatewayId = payoutPaymentGatewayId,
                                defaultPayinPaymentGatewayId = defaultPayinPaymentGatewayId,
                                code = code
                                )
                            if payinPaymentGatewaysList:
                                pattern_queryset.update(payinPaymentGatewaysList=[ObjectId(each_payin_pg) for each_payin_pg in payinPaymentGatewaysList])

                            flash("Pattern updated successfully.", "success")
                            data_status["responseStatus"]=1
                            return data_status
                        else:
                            flash("The provided ID is invalid. Please check and try again.", "error")
                            data_status["responseStatus"]=4
                            return data_status
                    else:
                        flash("Required fields are missing!!","warning")
                        data_status["responseStatus"]=2
                        return data_status
                else:
                    data_status["responseStatus"]=0
                    data_status["result"]=form.errors
                    return data_status
            else:
                flash("The request is invalid. Please check and try again.", "error")
                data_status["responseStatus"]=4
                return data_status
                       
           
        except Exception as e:
            app.logger.error(traceback.format_exc())
            error = "Unable to update pattern details."
            flash(error, "error")
            data_status["responseStatus"]=4
            return data_status
    else:
        flash("The staff member does not have permission to update Pattern.", "danger")
        data_status["responseStatus"]=4
        return data_status

@patterns_configuarations.route("/get_patterns_configuarations_list",methods=["POST","GET"])
@adminid_access_token_required
def get_patterns_configuarations_list():
    if not session.get("adminId"):
        return redirect("admin_login")
    
    patternsList = []
    userpermissionsList =[]
    transactionAPIsList =[]
    payinEnableList =[]
    payoutEnableList =[]
    ProfileSearchElement = ""
    profilePagination=""
    snoCount=0
    profilePage=""
    
    adminId = session.get("adminId")
    permissionsList = check_permissions(session.get("adminId"),"patternPermissions")
    form=ProfileSearchForm(request.args)
    if "view" in permissionsList:
        try:
            redirectTo = request.args.get("redirectTo","Pattern")
            if redirectTo:
                redirectval = redirectTo
            else:
                redirectval = "Pattern"
            ProfileSearchElement = request.args.get("ProfileSearchElement","")

            profilePage = request.args.get(get_page_parameter('profilePage'), type=int, default=1)

            filters = Q(status__in=[0, 1])
            if form.validate():
                filters = Q(status__in=[0, 1])

                per_page = 20
                start = (profilePage - 1) * per_page
                total_count = 0

                if ProfileSearchElement and ProfileSearchElement.strip():
                    filters&=Q(name__icontains=ProfileSearchElement.strip())

                total_count=Patterns.objects(filters).count()
                temp = math.ceil(total_count/per_page)
                print("%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%",temp)
                print("++++++++++++++++++++++++++++++++++++++++++++++++",profilePage)
                if profilePage>temp:
                    profilePage=1
                    start = 0

                patterns_queryset=(
                    Patterns.objects(filters)
                    .exclude("isCommission","isSuperDistributor","isAllow","isUserWise")
                    .order_by("-id")
                    .skip(start)
                    .limit(per_page)
                )
                
                patternsList=list(patterns_queryset)
            

                snoCount = start
                profilePagination = Pagination(profilePage=profilePage, total=total_count, page_parameter="profilePage", per_page=per_page, alignment="right", record_name="profile" , href=f"?ProfileSearchElement={ProfileSearchElement}&profilePage={{0}}")

                # patterns_queryset = Patterns.objects(status__in=[0,1]).order_by("-id")
                # if search_element:
                #     patterns_queryset = patterns_queryset.filter(Q(name__icontains=search_element))

                # for each_pattern in patterns_queryset:0
                #    pattern_dict = fetching_pattern_details(each_pattern)
                #    patternsList.append(pattern_dict)

                # print("(((((((((((((profilePagination)))))))))))))",profilePagination.links)

                # user_permissions_queryset = UserPermissions.objects(status__in=[0,1]).order_by("-id")
                # for each_user_permission in user_permissions_queryset:
                #     permission_dict = {
                #     "id":str(each_user_permission.id),
                #     "permissionName":each_user_permission.permissionName
                #     }
                #     userpermissionsList.append(permission_dict)

                userpermissionsList = list(
                    UserPermissions.objects
                    .filter(status__in=[0, 1])
                    .order_by("-id")
                    .only("id", "permissionName")
                )

                # 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,
                #     "transactionType":each_transaction_api.transactionType
                #     }
                #     transactionAPIsList.append(transactionapiDict)
                transactionAPIsList = list(
                    TransactionAPI.objects
                    .filter(status=1)
                    .order_by("-id")
                    .only("id", "apiName", "transactionType")
                )


                # payout_enable_queryset = TransactionAPI.objects(transactionType="Payout",status=1).order_by('-id')
                # for each_payout_enable in payout_enable_queryset:
                #     payoutDict = fetching_transaction_api_details(each_payout_enable)
                #     payoutEnableList.append(payoutDict)

                payoutEnableList = list(
                    TransactionAPI.objects
                    .filter(transactionType="Payout", status=1)
                    .order_by("-id")
                    .only("id", "apiName", "transactionType")  # Add more fields if needed
                )


                # payin_enable_queryset = TransactionAPI.objects(transactionType="PaymentGateway",status=1).order_by('-id')
                # for each_payin_enable in payin_enable_queryset:
                #     payinDict = fetching_transaction_api_details(each_payin_enable)
                #     payinEnableList.append(payinDict)

                payinEnableList = list(
                    TransactionAPI.objects
                    .filter(transactionType="PaymentGateway", status=1)
                    .order_by("-id")
                    .only("id", "apiName", "transactionType")  # Add fields as required
                )

            return render_template("super_admin_templates/patterns_configuarations_list.html",
                userpermissionsList=userpermissionsList,
                patternsList=patternsList,
                transactionAPIsList=transactionAPIsList,
                payinEnableList=payinEnableList,
                payoutEnableList=payoutEnableList,
                redirectval=redirectval,
                ProfileSearchElement=ProfileSearchElement,
                form=form,
                profilePagination=profilePagination,
                profilePage=profilePage,
                snoCount=snoCount
                )
        except Exception as e:
            app.logger.error(traceback.format_exc())
            error = "Unable to fetch patterns details!!"
            return render_template("super_admin_templates/patterns_configuarations_list.html", 
                error=error,
                userpermissionsList=userpermissionsList,
                patternsList=patternsList,
                transactionAPIsList=transactionAPIsList,
                payinEnableList=payinEnableList,
                payoutEnableList=payoutEnableList,
                ProfileSearchElement=ProfileSearchElement,
                form=form,
                profilePagination=profilePagination,
                profilePage=profilePage,
                snoCount=snoCount
                )
    else:
        flash("The staff member does not have permission to view Pattern", "danger")
        return render_template("super_admin_templates/patterns_configuarations_list.html")

@patterns_configuarations.route("/update_pattern_status",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def update_pattern_status():
    data_status={"responseStatus":0,"result":""}
    if not session.get("adminId"):
        data_status["responseStatus"]=4
        return data_status
    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()

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

    existing_record = ""
    updatedrequestData = [jsonData]
    remark = request.form.get("remark","")

    form=UpdateStatusRemarkForm()
    if form.validate_on_submit():
        permissionsList = check_permissions(session.get("adminId"),"patternPermissions")
        if "edit" in permissionsList:
            patternId = request.args.get("patternId","")

            if patternId:
                try:
                    pattern_queryset = Patterns.objects(id=patternId,status__in=[0,1]).first()
                    existing_record = pattern_queryset.to_json()
                    requestData = [existing_record]
                    if pattern_queryset:
                        if pattern_queryset.status == 0:
                            pattern_queryset.update(status=1)
                            flash("Pattern activated successfully.", "success")
                            message=pattern_queryset.adminId.userName+" "+pattern_queryset.name+" Pattern activated successfully!"
                        elif pattern_queryset.status == 1:
                            pattern_queryset.update(status=0)
                            flash("Pattern deactivated successfully.", "success")
                            message=pattern_queryset.adminId.userName+" "+pattern_queryset.name+" Pattern deactivated successfully!"
                        save_remarks_data=save_admin_remarks_data(patternId,adminId,remark,"Pattern Status")
                        save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_pattern_status","updatestatus",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)
                        data_status["responseStatus"]=1
                        return data_status
                    else:
                        flash("Invalid ID.", "error")
                        data_status["responseStatus"]=4
                        return data_status
                except Exception as e:
                    flash("Unable to update status.", "error")
                    app.logger.error(traceback.format_exc())
                    data_status["responseStatus"]=4
                    return data_status
            else:
                flash("Required field is missing!!","warning")
                data_status["responseStatus"]=2
                return data_status
        else:
            flash("The staff member does not have permission to update Pattern status.", "danger")
            data_status["responseStatus"]=4
            return data_status
    else:
        data_status["responseStatus"]=0
        data_status["result"]=form.errors
        return data_status


############### Setup Charge Commissions ################

@patterns_configuarations.route("/add_setup_charge_commission",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def add_setup_charge_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))))))))))))))")
        
        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(session.get("adminId"),"chargeCommissionsPermissions")
        if "add" in permissionsList:
            adminId = session.get("adminId")
            if request.method == "POST":
                slabName = request.form.get("slabName","")
                patternId = request.form.get("patternId","")
                paymentModeId = request.form.get("paymentModeId","")
                subPaymentModeId = request.form.get("subPaymentModeId","")
                transactionAPIId = request.form.get("transactionAPIId","")
                priceType = request.form.get("priceType","")
                aggregatorType = request.form.get("aggregatorType","")
                aggregatorValue = request.form.get("aggregatorValue",0)
                gstInclude = request.form.get("gstInclude","")
                gstValue = request.form.get("gstValue",0)
                tdsInclude = request.form.get("tdsInclude","")
                tdsValue = request.form.get("tdsValue",0)
                commissionType = request.form.get("commissionType","")
                commissionValue = request.form.get("commissionValue",0)
                chargeType = request.form.get("chargeType","")
                chargeValue = request.form.get("chargeValue",0)
                # Fetching lists from the form
                startAmountListField = request.form.getlist("startAmount[]")
                endAmountListField = request.form.getlist("endAmount[]")
                aggregatorTypeListField = request.form.getlist("aggregatorType[]")
                aggregatorValueListField = request.form.getlist("aggregatorValue[]")
                chargeTypeListField = request.form.getlist("chargeType[]")
                chargeValueListField = request.form.getlist("chargeValue[]")
                subPaymentModeIdsList = request.form.getlist("subPaymentModeIdsList")
                paymentModeIdsList = request.form.getlist("paymentModeIdsList")
                # patternIdsList = request.form.getlist("patternIdsList")
                transactionAPIIdsList = request.form.getlist("transactionAPIIdsList")
                # commissionTypeListField = request.form.getlist("commissionType[]")
                # commissionValueListField = request.form.getlist("commissionValue[]")
                jsonData = request.form.to_dict(flat=True)
                requestData = [jsonData]
                updatedrequestData = [jsonData]

                print(request.form, "((((((((((SLAB REQUEST FORM))))))))))")

                def try_float(value):
                    try:
                        return float(value)
                    except ValueError:
                        return None

                # Check if all lists have the same length
                if len(startAmountListField) == len(endAmountListField) == len(aggregatorTypeListField) == len(aggregatorValueListField) == len(chargeTypeListField) == len(chargeValueListField):
                    priceRangeList = [
                        {
                            'startAmount': try_float(startAmount),
                            'endAmount': try_float(endAmount),
                            'aggregatorType': aggregatorType,
                            'aggregatorValue': try_float(aggregatorValue),
                            'chargeType': chargeType,
                            'chargeValue': try_float(chargeValue)
                        }
                        for startAmount, endAmount, aggregatorType, aggregatorValue, chargeType, chargeValue in zip(
                            startAmountListField, endAmountListField, aggregatorTypeListField, aggregatorValueListField, chargeTypeListField, chargeValueListField
                        )
                        if try_float(startAmount) is not None and try_float(endAmount) is not None and try_float(aggregatorValue) is not None and try_float(chargeValue) is not None
                    ]
                else:
                    return redirect(url_for("patterns_configuarations.get_setup_charge_commissions_list"))


                print(priceRangeList, "((((((((priceRangeList))))))))")

                        
                if slabName and patternId and paymentModeIdsList and subPaymentModeIdsList and transactionAPIIdsList:
                    try:
                        admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                        if admin_queryset:
                            message=admin_queryset.userName+" "+slabName+" Setup charge commission created successfully!"
                            save_admin_log_table = save_admin_logs_data(adminId,None,None,"add_setup_charge_commission","create",actionDate,client_ip,browser,message,requestData,updatedrequestData) 

                        setup_charge_commissions_table = SetupChargeCommissions(
                            adminId=adminId,
                            slabName = slabName,
                            # patternId = patternId,
                            # paymentModeId = paymentModeId,
                            # subPaymentModeId = subPaymentModeId,
                            # transactionAPIId = transactionAPIId,
                            priceType = priceType,
                            aggregatorType = aggregatorType,
                            aggregatorValue = aggregatorValue,
                            gstInclude = gstInclude,
                            gstValue = gstValue,
                            tdsInclude = tdsInclude,
                            tdsValue = tdsValue,
                            commissionType = "",
                            commissionValue = 0,
                            chargeType = chargeType,
                            chargeValue = chargeValue,
                            priceRangeList = priceRangeList,
                            subPaymentModeIdsList = subPaymentModeIdsList,
                            paymentModeIdsList = paymentModeIdsList,
                            patternIdsList = [patternId],
                            transactionAPIIdsList = transactionAPIIdsList,
                            createdOn = datetime.datetime.now(),
                            status = 1,
                            )
                        save_table = setup_charge_commissions_table.save()

                        flash("Setup charge commission saved successfully!")
                        return redirect(url_for("patterns_configuarations.get_setup_charge_commissions_list",redirectTo="Commission"))
                    except Exception as e:
                        flash("Unable to save setup charge commission details!!")
                        app.logger.error(traceback.format_exc())
                        return redirect(url_for("patterns_configuarations.get_setup_charge_commissions_list",redirectTo="Commission"))
                else:
                    flash("Required fields are missing!!")
                    return redirect(url_for("patterns_configuarations.get_setup_charge_commissions_list",redirectTo="Commission"))
        else:
            flash("Staff member does not have given create setup charge commissions permissions!!")
            return redirect(url_for("patterns_configuarations.get_patterns_configuarations_list",redirectTo="Commission"))
    except Exception as e:
        app.logger.error(traceback.format_exc())
        error = "Unable to save setup charge commission details!!"
        return render_template("super_admin_templates/setup_charge_commissions_list.html",error=error,redirectTo="Commission")

def fetching_setup_charge_commission_details(setup_charge_commission_queryset):
    setup_charge_commission_dict = {}
    try:
        setup_charge_commission_dict={
        "id":str(setup_charge_commission_queryset.id),
        # "patternId":str(setup_charge_commission_queryset.patternId.id),
        # "patternName":setup_charge_commission_queryset.patternId.name,
        # "paymentModeId":str(setup_charge_commission_queryset.paymentModeId.id),
        # "paymentModeName":setup_charge_commission_queryset.paymentModeId.paymentMode,
        # "subPaymentModeId":str(setup_charge_commission_queryset.subPaymentModeId.id),
        # "subPaymentModeName":setup_charge_commission_queryset.subPaymentModeId.subPaymentModeType,
        # "transactionAPIId":str(setup_charge_commission_queryset.transactionAPIId.id),
        # "transactionAPIName":setup_charge_commission_queryset.transactionAPIId.apiName,
        "slabName":setup_charge_commission_queryset.slabName,
        "priceType":setup_charge_commission_queryset.priceType,
        # "startAmount":"{:.2f}".format(float(setup_charge_commission_queryset.startAmount)),
        # "endAmount":"{:.2f}".format(float(setup_charge_commission_queryset.endAmount)),
        "aggregatorType":setup_charge_commission_queryset.aggregatorType,
        # "aggregatorValue":"{:.2f}".format(float(setup_charge_commission_queryset.aggregatorValue)),
        "gstInclude":setup_charge_commission_queryset.gstInclude,
        "gstValue":setup_charge_commission_queryset.gstValue,
        "tdsInclude":setup_charge_commission_queryset.tdsInclude,
        "tdsValue":setup_charge_commission_queryset.tdsValue,
        "commissionType":setup_charge_commission_queryset.commissionType,
        "commissionValue":setup_charge_commission_queryset.commissionValue,
        "chargeType":setup_charge_commission_queryset.chargeType,
        # "chargeValue":"{:.2f}".format(float(setup_charge_commission_queryset.chargeValue)),
        "priceRangeList":setup_charge_commission_queryset.priceRangeList
        }
        if setup_charge_commission_queryset.status==1:
            setup_charge_commission_dict["actionText"] = "Active"
        else:
            setup_charge_commission_dict["actionText"] = "Deactive"

        if setup_charge_commission_queryset.aggregatorValue:
            setup_charge_commission_dict["aggregatorValue"] = "{:.2f}".format(float(setup_charge_commission_queryset.aggregatorValue))
        else:
            setup_charge_commission_dict["aggregatorValue"] = ""

        if setup_charge_commission_queryset.chargeValue:
            setup_charge_commission_dict["chargeValue"] = "{:.2f}".format(float(setup_charge_commission_queryset.chargeValue))
        else:
            setup_charge_commission_dict["chargeValue"] = ""

        if setup_charge_commission_queryset.transactionAPIIdsList:
            setup_charge_commission_dict["transactionAPIIdsList"]=[str(each_api.id) for each_api in setup_charge_commission_queryset.transactionAPIIdsList]
            setup_charge_commission_dict["apiNamesList"]=[str(each_api.apiName) for each_api in setup_charge_commission_queryset.transactionAPIIdsList]

            setup_charge_commission_dict["apiNames"] = ', '.join(setup_charge_commission_dict["apiNamesList"])
            # print(setup_charge_commission_dict["apiNames"],"(((((((((?????????????)))))))))")
        else:
            setup_charge_commission_dict["transactionAPIIdsList"]=[]
            setup_charge_commission_dict["apiNames"]=""

        if setup_charge_commission_queryset.patternIdsList:
            setup_charge_commission_dict["patternIdsList"]=[str(each_pattern.id) for each_pattern in setup_charge_commission_queryset.patternIdsList]

            setup_charge_commission_dict["patternNamesList"]=[str(each_pattern.name) for each_pattern in setup_charge_commission_queryset.patternIdsList]

            setup_charge_commission_dict["patternNames"] = ', '.join(setup_charge_commission_dict["patternNamesList"])

        else:
            setup_charge_commission_dict["patternIdsList"]=[]
            setup_charge_commission_dict["patternNames"]=""

        if setup_charge_commission_queryset.paymentModeIdsList:
            setup_charge_commission_dict["paymentModeIdsList"]=[str(each_paymentMode.id) for each_paymentMode in setup_charge_commission_queryset.paymentModeIdsList]

            setup_charge_commission_dict["paymentModeNamesList"]=[str(each_paymentMode.paymentMode) for each_paymentMode in setup_charge_commission_queryset.paymentModeIdsList]

            setup_charge_commission_dict["paymentModeNames"] = ', '.join(setup_charge_commission_dict["paymentModeNamesList"])

        else:
            setup_charge_commission_dict["paymentModeIdsList"]=[]
            setup_charge_commission_dict["paymentModeNames"]=""

        if setup_charge_commission_queryset.subPaymentModeIdsList:
            setup_charge_commission_dict["subPaymentModeIdsList"]=[str(each_subpaymentMode.id) for each_subpaymentMode in setup_charge_commission_queryset.subPaymentModeIdsList]

            setup_charge_commission_dict["subpaymentModeNamesList"]=[str(each_subpaymentMode.subPaymentModeType) for each_subpaymentMode in setup_charge_commission_queryset.subPaymentModeIdsList]

            setup_charge_commission_dict["subpaymentModeNames"] = ', '.join(setup_charge_commission_dict["subpaymentModeNamesList"])
        else:
            setup_charge_commission_dict["subPaymentModeIdsList"]=[]
            setup_charge_commission_dict["subpaymentModeNames"]=""

        if setup_charge_commission_queryset.createdOn:
            setup_charge_commission_dict["createdOn"] = setup_charge_commission_queryset.createdOn.strftime("%d-%m-%Y")
        else:
            setup_charge_commission_queryset["createdOn"] = ""
    except Exception as e:
        app.logger.error(traceback.format_exc())
    return setup_charge_commission_dict

@patterns_configuarations.route("/update_setup_charge_commission",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def update_setup_charge_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))))))))))))))")
    
    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"),"chargeCommissionsPermissions")
    if "edit" in permissionsList:
        try:
            transactionAPIsList = []
            patternsList = []
            paymentsModeList = []
            subPaymentsModeList = []

            commissionId = request.args.get("commissionId","")
            if request.method == "GET":
                setup_charge_commission_queryset = SetupChargeCommissions.objects(id=commissionId).first()
                if not setup_charge_commission_queryset:
                    flash("Invaild commission id!!")
                    return redirect(url_for("patterns_configuarations.get_setup_charge_commissions_list"))

                ######################## Common Lists ###########################
                transaction_API_queryset = TransactionAPI.objects(status__in=[0,1]).order_by('-id').all()
                for each_transaction_api in transaction_API_queryset:
                    service_grouping_dict = {
                    "id":str(each_transaction_api.id),
                    "apiName":each_transaction_api.apiName
                    }
                    transactionAPIsList.append(service_grouping_dict)

                patterns_queryset = Patterns.objects(status__in=[0,1]).order_by("-id").all()
                for each_pattern in patterns_queryset:
                    pattern_dict = fetching_pattern_details(each_pattern)
                    patternsList.append(pattern_dict)


                payments_mod_queryset = PaymentMode.objects(status__in=[0,1]).order_by("-id").all()
                for each_payment_mode in payments_mod_queryset:
                    payment_mode_data = fetching_payment_mode_details(each_payment_mode)
                    paymentsModeList.append(payment_mode_data)


                sub_payments_mod_queryset = SubPaymentModes.objects(status__in=[0,1],paymentModeId__in=setup_charge_commission_queryset.paymentModeIdsList).order_by("-id").all()
                for each_sub_payment_mode in sub_payments_mod_queryset:
                    sub_payment_mode_data = fetching_sub_payment_mode_details(each_sub_payment_mode)
                    subPaymentsModeList.append(sub_payment_mode_data)

                ###################################################################

                setup_charge_commission_dict = fetching_setup_charge_commission_details(setup_charge_commission_queryset)

                return render_template("super_admin_templates/update_setup_charge_commission.html",
                    setup_charge_commission_dict=setup_charge_commission_dict,
                    subPaymentsModeList=subPaymentsModeList,
                    transactionAPIsList=transactionAPIsList,
                    patternsList=patternsList,
                    paymentsModeList=paymentsModeList
                    )

            if request.method == "POST":
                action = request.form.get("action", "").strip()
                data = request.form.to_dict()
                # Step 1: Handle OTP Generation
               

                otp_check_id = request.form.get("otpLogid", "")
                print("otp_check_id",otp_check_id)
                if not otp_check_id:
                    flash("Invalid Request.")
                    return redirect(url_for("patterns_configuarations.get_setup_charge_commissions_list",redirectTo="Commission"))

                otpcheck_queryset = OtpChecks.objects(adminId=adminId, id=str(otp_check_id), status=1).first()

                if not otpcheck_queryset:
                    flash("Invalid Request.")
                    return redirect(url_for("patterns_configuarations.get_setup_charge_commissions_list",redirectTo="Commission"))
                # Update OTP status to 2 after verification
                otpcheck_queryset.update(status=2)

                slabName = request.form.get("slabName","")
                patternId = request.form.get("patternId","")
                paymentModeId = request.form.get("paymentModeId","")
                subPaymentModeId = request.form.get("subPaymentModeId","")
                transactionAPIId = request.form.get("transactionAPIId","")
                priceType = request.form.get("priceType","")
                aggregatorType = request.form.get("aggregatorType","")
                aggregatorValue = request.form.get("aggregatorValue",0)
                gstInclude = request.form.get("gstInclude","")
                gstValue = request.form.get("gstValue")
                tdsInclude = request.form.get("tdsInclude","")
                tdsValue = request.form.get("tdsValue",0)
                # commissionType = request.form.get("commissionType")
                # commissionValue = request.form.get("commissionValue",0)
                chargeType = request.form.get("chargeType")
                chargeValue = request.form.get("chargeValue",0)

                # Fetching lists from the form
                startAmountListField = request.form.getlist("startAmount[]")
                endAmountListField = request.form.getlist("endAmount[]")
                aggregatorTypeListField = request.form.getlist("aggregatorType[]")
                aggregatorValueListField = request.form.getlist("aggregatorValue[]")
                chargeTypeListField = request.form.getlist("chargeType[]")
                chargeValueListField = request.form.getlist("chargeValue[]")
                # commissionTypeListField = request.form.getlist("commissionType[]")
                # commissionValueListField = request.form.getlist("commissionValue[]")
                jsonData = request.form.to_dict(flat=True)
                remark = request.form.get("remark","")
                subPaymentModeIdsList = request.form.getlist("subPaymentModeIdsList")
                paymentModeIdsList = request.form.getlist("paymentModeIdsList")
                transactionAPIIdsList = request.form.getlist("transactionAPIIdsList")

                print(request.form, "((((((((((SLAB REQUEST FORM))))))))))")

                def try_float(value):
                    try:
                        return float(value)
                    except ValueError:
                        return None

                # Check if all lists have the same length
                if len(startAmountListField) == len(endAmountListField) == len(aggregatorTypeListField) == len(aggregatorValueListField) == len(chargeTypeListField) == len(chargeValueListField):
                    priceRangeList = [
                        {
                            'startAmount': try_float(startAmount),
                            'endAmount': try_float(endAmount),
                            'aggregatorType': aggregatorType,
                            'aggregatorValue': try_float(aggregatorValue),
                            'chargeType': chargeType,
                            'chargeValue': try_float(chargeValue)
                        }
                        for startAmount, endAmount, aggregatorType, aggregatorValue, chargeType, chargeValue in zip(
                            startAmountListField, endAmountListField, aggregatorTypeListField, aggregatorValueListField, chargeTypeListField, chargeValueListField
                        )
                        if try_float(startAmount) is not None and try_float(endAmount) is not None and try_float(aggregatorValue) is not None and try_float(chargeValue) is not None
                    ]
                else:
                    return redirect(url_for("patterns_configuarations.get_setup_charge_commissions_list"))


                print(priceRangeList, "((((((((priceRangeList))))))))")


                if commissionId and slabName and patternId and paymentModeIdsList and subPaymentModeIdsList and transactionAPIIdsList:
                    setup_charge_commission_queryset = SetupChargeCommissions.objects(id=commissionId,status__in=[0,1]).first()
                    existing_record = setup_charge_commission_queryset.to_json()
                    message=setup_charge_commission_queryset.adminId.userName+" "+slabName+" Setup charge commission updated successfully!"
                    requestData=[existing_record]
                    updatedrequestData=[jsonData]
                    save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_setup_charge_commission","update",actionDate,client_ip,browser,message,requestData,updatedrequestData)
                    save_remarks_data=save_admin_remarks_data(commissionId,adminId,remark,"commission")

                    if setup_charge_commission_queryset:
                        if priceType == "RANGE":
                            setup_charge_commission_queryset.update(
                                slabName = slabName,
                                # patternId = ObjectId(patternId),
                                # paymentModeId = ObjectId(paymentModeId),
                                # subPaymentModeId = ObjectId(subPaymentModeId),
                                # transactionAPIId = ObjectId(transactionAPIId),
                                priceType = priceType,
                                gstInclude = gstInclude,
                                gstValue = gstValue,
                                tdsInclude = tdsInclude,
                                tdsValue = tdsValue,
                                subPaymentModeIdsList = [ObjectId(each_sub_payment_mode) for each_sub_payment_mode in subPaymentModeIdsList],
                                paymentModeIdsList = [ObjectId(each_payment_mode) for each_payment_mode in paymentModeIdsList],
                                patternIdsList = [ObjectId(patternId)],
                                transactionAPIIdsList = [ObjectId(each_api) for each_api in transactionAPIIdsList]
                                )
                            if priceRangeList:
                                # existing_price_ranges_list = setup_charge_commission_queryset.priceRangeList or []
                                # print(existing_price_ranges_list,"Before Extend existing_price_ranges_list")
                                # existing_price_ranges_list.extend(priceRangeList)
                                # print(existing_price_ranges_list,"(((((((((((((existing_price_ranges_list)))))))))))))")
                                setup_charge_commission_queryset.update(priceRangeList=priceRangeList)
                        else:
                            setup_charge_commission_queryset.update(
                                slabName = slabName,
                                # patternId = ObjectId(patternId),
                                # paymentModeId = ObjectId(paymentModeId),
                                # subPaymentModeId = ObjectId(subPaymentModeId),
                                # transactionAPIId = ObjectId(transactionAPIId),
                                priceType = priceType,
                                aggregatorType = aggregatorType,
                                aggregatorValue = aggregatorValue,
                                gstInclude = gstInclude,
                                gstValue = gstValue,
                                tdsInclude = tdsInclude,
                                tdsValue = tdsValue,
                                commissionType = "",
                                commissionValue = 0,
                                chargeType = chargeType,
                                chargeValue = chargeValue,
                                priceRangeList = [],
                                subPaymentModeIdsList = [ObjectId(each_sub_payment_mode) for each_sub_payment_mode in subPaymentModeIdsList],
                                paymentModeIdsList = [ObjectId(each_payment_mode) for each_payment_mode in paymentModeIdsList],
                                patternIdsList = [ObjectId(patternId)],
                                transactionAPIIdsList = [ObjectId(each_api) for each_api in transactionAPIIdsList]
                                )
                        flash("Setup charge commission updated successfully!")
                        return redirect(url_for("patterns_configuarations.get_setup_charge_commissions_list",redirectTo="Commission"))
                    else:
                        flash("Invaild id!!")
                        return redirect(url_for("patterns_configuarations.get_setup_charge_commissions_list",redirectTo="Commission"))
                else:
                    flash("Required fields are missing!!")
                    return redirect(url_for("patterns_configuarations.get_setup_charge_commissions_list",redirectTo="Commission"))
        except Exception as e:
            app.logger.error(traceback.format_exc())
            error = "Unable to update setup charge commission details!!"
            flash(error)
            return redirect(url_for("patterns_configuarations.get_setup_charge_commissions_list",redirectTo="Commission"))
    else:
        flash("Staff member does not have given update setup charge commissions permissions!!")
        return redirect(url_for("patterns_configuarations.get_setup_charge_commissions_list",redirectTo="Commission"))

@patterns_configuarations.route("/get_setup_charge_commissions_list",methods=["POST","GET"])
@adminid_access_token_required
def get_setup_charge_commissions_list():
    if not session.get("adminId"):
        return redirect("admin_login")
    commissionsList = []
    transactionAPIsList = []
    patternsList = []
    paymentsModeList = []
    subPaymentsModeList = []
    
    adminId = session.get("adminId")
    permissionsList = check_permissions(session.get("adminId"),"chargeCommissionsPermissions")
    if "view" in permissionsList:
        try:
            redirectTo = request.args.get("redirectTo","Commission")
            if redirectTo:
                redirectval = redirectTo
            else:
                redirectval = "Commission"
            search_element = request.form.get("search_element","")

            ######################## Common Lists ###########################
            transaction_API_queryset = TransactionAPI.objects(status__in=[0,1]).order_by('-id').all()
            for each_transaction_api in transaction_API_queryset:
                service_grouping_dict = {
                "id":str(each_transaction_api.id),
                "apiName":each_transaction_api.apiName
                }
                transactionAPIsList.append(service_grouping_dict)

            patterns_queryset = Patterns.objects(status__in=[0,1]).order_by("-id").all()
            for each_pattern in patterns_queryset:
                pattern_dict = fetching_pattern_details(each_pattern)
                patternsList.append(pattern_dict)


            payments_mod_queryset = PaymentMode.objects(status__in=[0,1]).order_by("-id").all()
            for each_payment_mode in payments_mod_queryset:
                payment_mode_data = fetching_payment_mode_details(each_payment_mode)
                paymentsModeList.append(payment_mode_data)


            sub_payments_mod_queryset = SubPaymentModes.objects(status__in=[0,1]).order_by("-id").all()
            for each_sub_payment_mode in sub_payments_mod_queryset:
                sub_payment_mode_data = fetching_sub_payment_mode_details(each_sub_payment_mode)
                subPaymentsModeList.append(sub_payment_mode_data)

            
            setup_charge_commissions_queryset = SetupChargeCommissions.objects(status__in=[0,1]).order_by("-id")
            if search_element:
                setup_charge_commissions_queryset = setup_charge_commissions_queryset.filter(Q(slabName__icontains=search_element))

            for each_setup_charge_commission in setup_charge_commissions_queryset:
                setup_charge_commission_dict = fetching_setup_charge_commission_details(each_setup_charge_commission)
                commissionsList.append(setup_charge_commission_dict)
            
            return render_template("super_admin_templates/setup_charge_commissions_list.html",
                commissionsList=commissionsList,
                subPaymentsModeList=subPaymentsModeList,
                patternsList=patternsList,
                paymentsModeList=paymentsModeList,
                transactionAPIsList=transactionAPIsList,
                redirectval=redirectval,
                search_element=search_element
                )
        except Exception as e:
            app.logger.error(traceback.format_exc())
            error = "Unable to fetch setup charge commission details!!"
            return render_template("super_admin_templates/setup_charge_commissions_list.html", 
                error=error,
                commissionsList=commissionsList,
                subPaymentsModeList=subPaymentsModeList,
                patternsList=patternsList,
                paymentsModeList=paymentsModeList,
                transactionAPIsList=transactionAPIsList,
                search_element=search_element
                )
    else:
        flash("Staff member does not have given view setup charge commissions permissions!!")
        return render_template("super_admin_templates/setup_charge_commissions_list.html")

@patterns_configuarations.route("/update_setup_charge_commission_status",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def update_setup_charge_commission_status():
    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))))))))))))))")
    
    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]
    remark = request.form.get("remark","")

    permissionsList = check_permissions(session.get("adminId"),"chargeCommissionsPermissions")
    if "edit" in permissionsList:
        commissionId = request.args.get("commissionId","")

        if commissionId:
            try:
                setup_charge_commission_queryset = SetupChargeCommissions.objects(id=commissionId,status__in=[0,1]).first()
                existing_record = setup_charge_commission_queryset.to_json()
                requestData = [existing_record]
                if setup_charge_commission_queryset:
                    if setup_charge_commission_queryset.status == 0:
                        setup_charge_commission_queryset.update(status=1)
                        flash("Setup charge commission activated successfully!")
                        message=setup_charge_commission_queryset.adminId.userName+" "+setup_charge_commission_queryset.slabName+" Setup charge commission activated successfully!"
                    elif setup_charge_commission_queryset.status == 1:
                        setup_charge_commission_queryset.update(status=0)
                        flash("Setup charge commission deactivated successfully!")
                        message=setup_charge_commission_queryset.adminId.userName+" "+setup_charge_commission_queryset.slabName+" Setup charge commission deactivated successfully!"
                    save_remarks_data=save_admin_remarks_data(commissionId,adminId,remark,"commission")
                    save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_setup_charge_commission_status","updatestatus",actionDate,client_ip,browser,message,requestData,updatedrequestData)     
                    return redirect(url_for("patterns_configuarations.get_setup_charge_commissions_list",redirectTo="Commission"))
                else:
                    flash("Invaild id!!")
                    return redirect(url_for("patterns_configuarations.get_setup_charge_commissions_list",redirectTo="Commission"))
            except Exception as e:
                app.logger.error(traceback.format_exc())
                return redirect(url_for("patterns_configuarations.get_setup_charge_commissions_list",redirectTo="Commission"))
        else:
            flash("Required field is missing!!")
            return redirect(url_for("patterns_configuarations.get_setup_charge_commissions_list",redirectTo="Commission"))
    else:
        flash("Staff member does not have given status update setup charge commissions permissions!!")
        return redirect(url_for("patterns_configuarations.get_setup_charge_commissions_list",redirectTo="Commission"))



@patterns_configuarations.route("/sub_payment_based_payment_modes_list", methods=["POST"])
@adminid_access_token_required
def sub_payment_based_payment_modes_list():
    data_status = {"responseStatus": 0, "result": ""}
    # Get paymentModeIdsList as a string, then split if necessary
    paymentModeIdsList = request.form.getlist("paymentModeIdsList[]")
    
    # If it's a single string with comma-separated ObjectIds, split it
    if isinstance(paymentModeIdsList, str):
        paymentModeIdsList = paymentModeIdsList.split(",")
    
    print(paymentModeIdsList, "((((((((((paymentModeIdsList))))))))))")
    
    # If the list is empty, return an error
    if not paymentModeIdsList:
        data_status["result"] = "Required fields are missing!!"
        return data_status

    try:
        payment_mod_queryset = PaymentMode.objects(id__in=paymentModeIdsList, status__in=[0, 1])
        paymentModesList = [str(each_payment_mode.id) for each_payment_mode in payment_mod_queryset]
        print(paymentModesList, "paymentModesList")

        subPaymentsModeList = []
        sub_payments_mod_queryset = SubPaymentModes.objects(
            paymentModeId__in=paymentModesList, status__in=[0, 1]
        ).order_by("-id").all()

        for each_sub_payment_mode in sub_payments_mod_queryset:
            subPaymentsModeDict = fetching_sub_payment_mode_details(each_sub_payment_mode)
            subPaymentsModeList.append(subPaymentsModeDict)

        data_status["responseStatus"] = 1
        data_status["result"] = "PaymentMode based sub payments data fetched successfully!"
        data_status["subPaymentsModeList"] = subPaymentsModeList
        return data_status
    
    except Exception as e:
        app.logger.error(traceback.format_exc())
        data_status["result"] = "Unable to fetch sub payments data!!"
        return data_status

# @patterns_configuarations.route("/sub_payment_based_payment_modes_list", methods=["POST"])
# def sub_payment_based_payment_modes_list():
#     data_status = {"responseStatus": 0, "result": ""}
#     # Get paymentModeIdsList as a string, then split if necessary
#     paymentModeIdsList = request.form.getlist("paymentModeIdsList[]")
    
#     # If it's a single string with comma-separated ObjectIds, split it
#     if isinstance(paymentModeIdsList, str):
#         paymentModeIdsList = paymentModeIdsList.split(",")
    
#     print(paymentModeIdsList, "((((((((((paymentModeIdsList))))))))))")
    
#     # If the list is empty, return an error
#     if not paymentModeIdsList:
#         data_status["result"] = "Required fields are missing!!"
#         return data_status

#     try:
#         payment_mod_queryset = PaymentMode.objects(id__in=paymentModeIdsList, status__in=[0, 1])
#         paymentModesList = [str(each_payment_mode.id) for each_payment_mode in payment_mod_queryset]
#         print(paymentModesList, "paymentModesList")

#         subPaymentsModeList = []
#         sub_payments_mod_queryset = SubPaymentModes.objects(
#             paymentModeId__in=paymentModesList, status__in=[0, 1]
#         ).order_by("-id").all()

#         for each_sub_payment_mode in sub_payments_mod_queryset:
#             subPaymentsModeDict = {
#             "value":str(each_sub_payment_mode.id),
#             "label":str(each_sub_payment_mode.subPaymentModeType)
#             }
#             subPaymentsModeList.append(subPaymentsModeDict)

#         data_status["responseStatus"] = 1
#         data_status["result"] = "PaymentMode based sub payments data fetched successfully!"
#         data_status["subPaymentsModeList"] = subPaymentsModeList
#         return data_status
    
#     except Exception as e:
#         app.logger.error(traceback.format_exc())
#         data_status["result"] = "Unable to fetch sub payments data!!"
#         return data_status

@patterns_configuarations.route("/new_get_setup_charge_commissions_list", methods=["POST", "GET"])
@adminid_access_token_required
def new_get_setup_charge_commissions_list():
    if not session.get("adminId"):
        return redirect("admin_login")
    
    # Initialize lists
    commissionsList = []
    transactionAPIsList = []
    patternsList = []
    paymentsModeList = []
    subPaymentsModeList = []
    error = None
    success_message = None
    editable = False
    update = False

    adminId = session.get("adminId")
    permissionsList = check_permissions(session.get("adminId"), "chargeCommissionsPermissions")

    if "view" in permissionsList:
        try:
            redirectTo = request.args.get("redirectTo", "Commission")
            search_action = request.args.get("action")

            ######################## Common Lists ###########################
            transaction_API_queryset = TransactionAPI.objects(status__in=[0, 1]).order_by('-id').all()
            for each_transaction_api in transaction_API_queryset:
                service_grouping_dict = {
                    "id": str(each_transaction_api.id),
                    "apiName": each_transaction_api.apiName
                }
                transactionAPIsList.append(service_grouping_dict)

            patterns_queryset = Patterns.objects(status__in=[0, 1]).order_by("-id").all()
            for each_pattern in patterns_queryset:
                patternsList.append(fetching_pattern_details(each_pattern))

            payments_mod_queryset = PaymentMode.objects(status__in=[0, 1]).order_by("-id").all()
            for each_payment_mode in payments_mod_queryset:
                paymentsModeList.append(fetching_payment_mode_details(each_payment_mode))

            sub_payments_mod_queryset = SubPaymentModes.objects(status__in=[0, 1]).order_by("-id").all()
            for each_sub_payment_mode in sub_payments_mod_queryset:
                subPaymentsModeList.append(fetching_sub_payment_mode_details(each_sub_payment_mode))

            if request.method == "GET" and request.args.get("action") == "search":
                patternId = request.args.get("patternId")
                paymentModeId = request.args.get("paymentModeId")
                subPaymentModeId = request.args.get("subPaymentModeId")
                transactionAPIId = request.args.get("transactionAPIId")
                editable = True
                update = True

                # Search for matching records
                setup_charge_commission = SetupChargeCommissions.objects(
                    patternId=patternId,
                    paymentModeId=paymentModeId,
                    transactionAPIId=transactionAPIId,
                    status=1
                ).first()

                if setup_charge_commission:
                    print("charge type =",setup_charge_commission.chargeType)
                    print("++++++++++++++++++",setup_charge_commission["priceRangeList"],setup_charge_commission)
                    startAmountList, endAmountList, isUnlimitedList = [], [], []
                    aggregatorTypeListField, aggregatorValueListField = [], []
                    chargeTypeListField, chargeValueListField = [], []
                    if setup_charge_commission.priceType == 'RANGE':
                        price_ranges = setup_charge_commission.priceRangeList
                        
                        
                    else:
                        price_ranges = []

                    
                    flash("Matching record found! You can update it.", "success")
                    return render_template(
                        "super_admin_templates/new_setup_charge_commissions_list.html",
                        patternId=patternId,
                        recordId=setup_charge_commission.id,
                        paymentModeId=paymentModeId,
                        transactionAPIId=transactionAPIId,
                        subPaymentsModeList=subPaymentsModeList,
                        patternsList=patternsList,
                        paymentsModeList=paymentsModeList,
                        transactionAPIsList=transactionAPIsList,
                        editable=editable,
                        priceType=setup_charge_commission.priceType,
                        aggregatorType=setup_charge_commission.aggregatorType,
                        aggregatorValue=setup_charge_commission.aggregatorValue,
                        chargeType=setup_charge_commission.chargeType,
                        chargeValue=setup_charge_commission.chargeValue,
                        gstInclude=setup_charge_commission.gstInclude,
                        gstValue=setup_charge_commission.gstValue,
                        tdsInclude=setup_charge_commission.tdsInclude,
                        tdsValue=setup_charge_commission.tdsValue,
                        priceRangeList=price_ranges,
                        update= update
                    )
                else:
                    flash("No matching record found. Please add a new record.", "error")
                    return render_template("super_admin_templates/new_setup_charge_commissions_list.html",
                                        patternId=patternId,
                                        paymentModeId=paymentModeId,
                                        # subPaymentModeId=subPaymentModeId,
                                        transactionAPIId=transactionAPIId,
                                        subPaymentsModeList=subPaymentsModeList,
                                        patternsList=patternsList,
                                        paymentsModeList=paymentsModeList,
                                        transactionAPIsList=transactionAPIsList,
                                        editable=editable
                    )

            elif request.method == "POST" and request.form.get("action") == "submit":
                editable = True
                record_id = request.form.get("recordId")

                if record_id:  # Update existing record
                    existing_record = SetupChargeCommissions.objects.get(id=record_id)
                    existing_record.patternId = ObjectId(request.form.get("patternId"))
                    existing_record.paymentModeId = ObjectId(request.form.get("paymentModeId"))
                    existing_record.transactionAPIId = ObjectId(request.form.get("transactionAPIId"))
                    existing_record.priceType = request.form.get("priceType")
                    existing_record.aggregatorType = request.form.get("aggregatorType")
                    existing_record.chargeType = request.form.get("chargeType")

                    # Convert numeric fields to float
                    try:
                        existing_record.aggregatorValue = float(request.form.get("aggregatorValue", 0))
                        existing_record.chargeValue = float(request.form.get("chargeValue", 0))
                        existing_record.gstValue = float(request.form.get("gstValue", 0))
                        existing_record.tdsValue = float(request.form.get("tdsValue", 0))

                        if existing_record.priceType == 'RANGE':
                            startAmountListField = request.form.getlist("startAmount[]")
                            endAmountListField = request.form.getlist("endAmount[]")
                            aggregatorTypeListField = request.form.getlist("aggregatorType[]")
                            aggregatorValueListField = request.form.getlist("aggregatorValue[]")
                            chargeTypeListField = request.form.getlist("chargeType[]")
                            chargeValueListField = request.form.getlist("chargeValue[]")
                            isUnlimited= request.form.getlist("isUnlimited")
                            print("uuuu___________________________________________", request.form.to_dict(),isUnlimited)

                            def try_float(value):
                                print(f"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@Trying to convert value: '{value}'")  # Print value being converted
                                if value.strip() == "":
                                    print("Empty string encountered.")
                                    return None
                                try:
                                    return float(value)
                                except ValueError:
                                    print(f"ValueError: Cannot convert '{value}' to float.")
                                    return None
                            
                            priceRangeList = []
                            print("startAmountListField++++",startAmountListField, "endAmountListField",endAmountListField,"aggregatorTypeListField",aggregatorTypeListField,"aggregatorValueListField",aggregatorValueListField,"chargeTypeListField",chargeTypeListField,"chargeValueListField",chargeValueListField,"isunlimited:::::",isUnlimited)

                            # Validate that all lists have the same length
                            if (len(startAmountListField) == len(endAmountListField) ==
                                len(aggregatorTypeListField) == len(aggregatorValueListField) ==
                                len(chargeTypeListField) == len(chargeValueListField)):
                                
                                isUnlimitedLastRow = isUnlimited[0] == 'on' if isUnlimited else False

                                for startAmount, endAmount, aggregatorType, aggregatorValue, chargeType, chargeValue in zip(
                                        startAmountListField, endAmountListField, aggregatorTypeListField, aggregatorValueListField, 
                                        chargeTypeListField, chargeValueListField):
                                    
                                    startAmountFloat = try_float(startAmount)
                                    endAmountFloat = try_float(endAmount)
                                    aggregatorValueFloat = try_float(aggregatorValue)
                                    chargeValueFloat = try_float(chargeValue)



                                    print(f"CCCCCCCCCCCCCCCCCCCCCConverted Values - Start: {startAmountFloat}, End: {endAmountFloat}, "
                                        f"Aggregator: {aggregatorValueFloat}, Charge: {chargeValueFloat}, isunlimited: {isUnlimited}")

                                    if None not in (startAmountFloat, endAmountFloat, aggregatorValueFloat, chargeValueFloat):
                                        priceRangeList.append({
                                            'startAmount': startAmountFloat,
                                            'endAmount': endAmountFloat,
                                            'aggregatorType': aggregatorType,  # Adding this for clarity
                                            'aggregatorValue': aggregatorValueFloat,
                                            'chargeType': chargeType,           # Adding this for clarity
                                            'chargeValue': chargeValueFloat,
                                            'isUnlimited': isUnlimitedLastRow if endAmount == endAmountListField[-1] else False                                
                                            })
                                print("=====================================Final Price Range List:", priceRangeList)
                                existing_record.priceRangeList = priceRangeList
                            else:
                                flash("Mismatch in input lengths for price ranges.", "error")
                                return redirect(url_for("patterns_configuarations.new_get_setup_charge_commissions_list"))

                                # Assign the constructed price range list to the existing record
                    except ValueError:
                        flash("Invalid input for numeric fields.", "error")
                        return render_template("super_admin_templates/new_setup_charge_commissions_list.html")

                    existing_record.gstInclude = request.form.get("gstInclude")
                    existing_record.tdsInclude = request.form.get("tdsInclude")

                    

                    existing_record.save()
                    flash("Record updated successfully!", "success")
                    return render_template(
                        "super_admin_templates/new_setup_charge_commissions_list.html",
                        patternId=str(existing_record.patternId),
                        recordId=existing_record.id,
                        paymentModeId=str(existing_record.paymentModeId),
                        transactionAPIId=str(existing_record.transactionAPIId),
                        # subPaymentsModeList=subPaymentsModeList,
                        patternsList=patternsList,
                        paymentsModeList=paymentsModeList,
                        transactionAPIsList=transactionAPIsList,
                        editable=editable,
                        priceType=existing_record.priceType,
                        aggregatorType=existing_record.aggregatorType,
                        aggregatorValue=existing_record.aggregatorValue,
                        chargeType=existing_record.chargeType,
                        chargeValue=existing_record.chargeValue,
                        gstInclude=existing_record.gstInclude,
                        gstValue=existing_record.gstValue,
                        tdsInclude=existing_record.tdsInclude,
                        tdsValue=existing_record.tdsValue,
                        priceRangeList=existing_record.priceRangeList,
                        update= update
                    )


                else:  # Insert a new record
                    # slabName = request.form.get("slabName", "")
                    patternId = request.form.get("patternId", "")
                    paymentModeId = request.form.get("paymentModeId", "")
                    # subPaymentModeId = request.form.get("subPaymentModeId", "")
                    transactionAPIId = request.form.get("transactionAPIId", "")
                    priceType = request.form.get("priceType", "")
                    aggregatorType = request.form.get("aggregatorType", "")
                    aggregatorValue = request.form.get("aggregatorValue", 0)
                    gstInclude = request.form.get("gstInclude", "")
                    gstValue = request.form.get("gstValue", 0)
                    tdsInclude = request.form.get("tdsInclude", "")
                    tdsValue = request.form.get("tdsValue", 0)
                    chargeType = request.form.get("chargeType", "")
                    chargeValue = request.form.get("chargeValue", 0)

                    # Fetching lists from the form
                    isUnlimited = request.form.getlist("isUnlimited")
                    startAmountListField = request.form.getlist("startAmount[]")
                    endAmountListField = request.form.getlist("endAmount[]")
                    aggregatorTypeListField = request.form.getlist("aggregatorType[]")
                    aggregatorValueListField = request.form.getlist("aggregatorValue[]")
                    chargeTypeListField = request.form.getlist("chargeType[]")
                    chargeValueListField = request.form.getlist("chargeValue[]")
                    # subPaymentModeIdsList = request.form.getlist("subPaymentModeIdsList")
                    # paymentModeIdsList = request.form.getlist("paymentModeIdsList")
                    # transactionAPIIdsList = request.form.getlist("transactionAPIIdsList")
                    

                    jsonData = request.form.to_dict(flat=True)
                    requestData = [jsonData]
                    updatedrequestData = [jsonData]
 
                    print(request.form, "((((((((((SLAB REQUEST FORM))))))))))")
                   
                    def try_float(value):
                        print(f"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@Trying to convert value: '{value}'")  # Print value being converted
                        if value.strip() == "":
                            print("Empty string encountered.")
                            return None
                        try:
                            return float(value)
                        except ValueError:
                            print(f"ValueError: Cannot convert '{value}' to float.")
                            return None
                        
                    priceRangeList = []


                    print("startAmountListField++++",startAmountListField)


                    # Check if all lists have the same length
                    # Check if all lists have the same length
                    if (len(startAmountListField) == len(endAmountListField) ==
                        len(aggregatorTypeListField) == len(aggregatorValueListField) ==
                        len(chargeTypeListField) == len(chargeValueListField)):

                        isUnlimitedLastRow = isUnlimited[0] == 'on' if isUnlimited else False
                        
                        
                        for startAmount, endAmount, aggregatorType, aggregatorValue, chargeType, chargeValue in zip(
                                startAmountListField, endAmountListField, aggregatorTypeListField, aggregatorValueListField, 
                                chargeTypeListField, chargeValueListField):
                            
                            startAmountFloat = try_float(startAmount)
                            endAmountFloat = try_float(endAmount)
                            aggregatorValueFloat = try_float(aggregatorValue)
                            chargeValueFloat = try_float(chargeValue)

                            print(f"Converted Values - Start: {startAmountFloat}, End: {endAmountFloat}, "
                                f"Aggregator: {aggregatorValueFloat}, Charge: {chargeValueFloat}")

                            if None not in (startAmountFloat, endAmountFloat, aggregatorValueFloat, chargeValueFloat):
                                priceRangeList.append({
                                    'startAmount': startAmountFloat,
                                    'endAmount': endAmountFloat,
                                    'aggregatorType': aggregatorType,  # Adding this for clarity
                                    'aggregatorValue': aggregatorValueFloat,
                                    'chargeType': chargeType,           # Adding this for clarity
                                    'chargeValue': chargeValueFloat,
                                    'isUnlimited': isUnlimitedLastRow if endAmount == endAmountListField[-1] else False
                                })

                        # print("Final Price Range List:",[i for i in priceRangeList])



                    else:
                        flash("Mismatch in input lengths for price ranges.", "error")
                        return redirect(url_for("patterns_configuarations.new_get_setup_charge_commissions_list"))

                    if patternId:
                        try:
                            def try_float(value):
                                print(f"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@Trying to convert value: '{value}'")  # Print value being converted
                                if value.strip() == "":
                                    print("Empty string encountered.")
                                    return None
                                try:
                                    return float(value)
                                except ValueError:
                                    print(f"ValueError: Cannot convert '{value}' to float.")
                                    return None
                        
                            aggregatorValue = try_float(request.form.get("aggregatorValue"))
                            gstValue = try_float(request.form.get("gstValue"))
                            tdsValue = try_float(request.form.get("tdsValue"))
                            chargeValue = try_float(request.form.get("chargeValue"))
                            
                            new_record = SetupChargeCommissions(
                                adminId=adminId,
                                # slabName=slabName,
                                patternId=ObjectId(patternId),
                                paymentModeId=ObjectId(paymentModeId),
                                transactionAPIId=ObjectId(transactionAPIId),
                                priceType=priceType,
                                aggregatorType=aggregatorType,
                                aggregatorValue=float(aggregatorValue) if aggregatorValue is not None else None,  # Convert to float, check for None
                                gstInclude=gstInclude,  # Ensure gstInclude is correctly defined (boolean)
                                gstValue=float(gstValue) if gstValue is not None else None,  # Convert to float, check for None
                                tdsInclude=tdsInclude,  # Ensure tdsInclude is correctly defined (boolean)
                                tdsValue=float(tdsValue) if tdsValue is not None else None,  # Convert to float, check for None
                                chargeType=chargeType,  # Ensure chargeType is defined correctly
                                chargeValue=float(chargeValue) if chargeValue is not None else None,  # Convert to float, check for None
                                priceRangeList=priceRangeList,  # Ensure priceRangeList is populated as expected
                                # subPaymentModeIdsList=[ObjectId(each_sub_payment_mode) for each_sub_payment_mode in subPaymentModeIdsList],
                                # paymentModeIdsList=[ObjectId(each_payment_mode) for each_payment_mode in paymentModeIdsList],
                                # patternIdsList=[ObjectId(patternId)],
                                # transactionAPIIdsList=[ObjectId(each_api) for each_api in transactionAPIIdsList],
                                createdOn=datetime.datetime.now(),
                                status=1,
                            )
                            print("bbbbbbbbbbbbbbbbb____________________________________________________________________agggg", request.form.get("aggregatorType"),
                        f"Updated Record: Pattern ID: {patternId}, Payment Mode ID: {paymentModeId}, "
                        f"Transaction API ID: {transactionAPIId}, "
                        f"Price Type: {priceType}, Aggregator Type: {aggregatorType}, "
                        f"Aggregator Value: {aggregatorValue}, Charge Type: {chargeType}, "
                        f"Charge Value: {chargeValue}, GST Include: {gstInclude}, "
                        f"GST Value: {gstValue}, TDS Include: {tdsInclude}, "
                        f"TDS Value: {tdsValue}","Pricelist: {priceRangeList}")

                            new_record.save()
                            flash("Setup charge commission created successfully!", "success")

                            



                            return render_template(
                        "super_admin_templates/new_setup_charge_commissions_list.html",
                        patternId=str(patternId),
                        paymentModeId=str(paymentModeId),
                        transactionAPIId=str(transactionAPIId),
                        # subPaymentsModeList=subPaymentsModeList,
                        patternsList=patternsList,
                        paymentsModeList=paymentsModeList,
                        transactionAPIsList=transactionAPIsList,
                        editable=editable,
                        priceType=priceType,
                        aggregatorType=aggregatorType,
                        aggregatorValue=aggregatorValue,
                        chargeType=chargeType,
                        chargeValue=chargeValue,
                        gstInclude=gstInclude,
                        gstValue=gstValue,
                        tdsInclude=tdsInclude,
                        tdsValue=tdsValue,
                        priceRangeList=priceRangeList,
                        update= update
                    )

                        except Exception as e:
                            flash(f"Error while creating setup charge commission: {str(e)}", "error")
                            return redirect(url_for("patterns_configuarations.new_get_setup_charge_commissions_list"))

                    else:
                        flash("Required fields are missing!", "error")
                        return redirect(url_for("patterns_configuarations.new_get_setup_charge_commissions_list"))  



            return render_template("super_admin_templates/new_setup_charge_commissions_list.html",
                commissionsList=commissionsList,
                subPaymentsModeList=subPaymentsModeList,
                patternsList=patternsList,
                paymentsModeList=paymentsModeList,
                transactionAPIsList=transactionAPIsList,
                redirectval=redirectTo,
                error=error,
                editable=editable,
                success_message=success_message
            )

        except Exception as e:
            app.logger.error(traceback.format_exc())
            error = "Unable to fetch setup charge commission details!!"
            flash(error, "error")
            return render_template("super_admin_templates/new_setup_charge_commissions_list.html",commissionsList=commissionsList,
                subPaymentsModeList=subPaymentsModeList,
                patternsList=patternsList,
                paymentsModeList=paymentsModeList,
                transactionAPIsList=transactionAPIsList,
                redirectval=redirectTo,
                error=error,
                editable=editable,
                success_message=success_message
                )

@patterns_configuarations.route("/get_merchant_setup_charge_commissions_list", methods=["POST", "GET"])
@adminid_access_token_required
def get_merchant_setup_charge_commissions_list():
    if not session.get("adminId"):
        return redirect("admin_login")
    
    # Initialize lists
    commissionsList = []
    patternsList = []
    paymentsModeList = []
    subPaymentsModeList = []
    error = None
    success_message = None
    editable = False
    update = False
    setup_charge_commission={}
    setup_charge_commission_dict={}
    setup_charge_commission_list=[]
    price_ranges = []

    adminId = session.get("adminId")
    permissionsList = check_permissions(session.get("adminId"), "chargeCommissionsPermissions")

    if "view" in permissionsList:
        try:
            action = request.form.get("action", "").strip()
            data = request.form.to_dict()
            # Step 1: Handle OTP Generation
            # otp_check_id = request.form.get("otpLogid", "")
            # print("otp_check_id",otp_check_id)
            # if not otp_check_id:
            #     flash("Invalid Request.")
            #     return render_template("super_admin_templates/merchant_setup_charge_commissions_list.html")

            # otpcheck_queryset = OtpChecks.objects(adminId=adminId, id=str(otp_check_id), status=1).first()

            # if not otpcheck_queryset:
            #     flash("Invalid Request.")
            #     return render_template("super_admin_templates/merchant_setup_charge_commissions_list.html")
            # # Update OTP status to 2 after verification
            # otpcheck_queryset.update(status=2)

            redirectTo = request.args.get("redirectTo", "Commission")
            search_action = request.args.get("action")

            ######################## Common Lists ###########################

            patterns_queryset = Patterns.objects(status__in=[0, 1]).order_by("-id").all()
            for each_pattern in patterns_queryset:
                patternsList.append(fetching_pattern_details(each_pattern))

            payments_mod_queryset = PaymentMode.objects(status__in=[0, 1]).order_by("-id").all()
            for each_payment_mode in payments_mod_queryset:
                paymentsModeList.append(fetching_payment_mode_details(each_payment_mode))

         

            if request.method == "GET" and request.args.get("action") == "search":
                patternId = request.args.get("patternId")
                paymentModeId = request.args.get("paymentModeId")
                subPaymentModeId = request.args.get("subPaymentModeId")
                editable = True
                update = True

                # print(patternId,"(((((((((patternId)))))))))")
                # print(paymentModeId,"(((((((((paymentModeId)))))))))")
                # print(subPaymentModeId,"(((((((((subPaymentModeId)))))))))")

                # Search for matching records
                

                sub_payments_mod_queryset = SubPaymentModes.objects(paymentModeId=paymentModeId,status__in=[0, 1]).order_by("-id").all()
                for each_sub_payment_mode in sub_payments_mod_queryset:
                    setup_charge_commission_queryset = SetupChargeCommissions.objects(paymentModeIdsList__in=[paymentModeId],subPaymentModeIdsList__in=[str(each_sub_payment_mode.id)],patternIdsList__in=[patternId],
                    status=1).first()

                    if setup_charge_commission_queryset:
                        price_ranges=[]
                        if setup_charge_commission_queryset.priceType == 'RANGE':
                            price_ranges = setup_charge_commission_queryset.priceRangeList
                        setup_charge_commission_dict= {
                            "id":str(each_sub_payment_mode.id),
                            "subPaymentModeType": each_sub_payment_mode.subPaymentModeType,  # Use the subPaymentModeType
                            "subPaymentModeId": str(each_sub_payment_mode.id),  # Keep the ID for reference
                            "priceType": setup_charge_commission_queryset.priceType,
                            "chargeType": setup_charge_commission_queryset.chargeType,
                            "chargeValue": setup_charge_commission_queryset.chargeValue,
                            "gstInclude": setup_charge_commission_queryset.gstInclude,
                            "gstValue": setup_charge_commission_queryset.gstValue,
                            "tdsInclude": setup_charge_commission_queryset.tdsInclude,
                            "tdsValue": setup_charge_commission_queryset.tdsValue,
                            "price_ranges": price_ranges
                        }
                    else:
                        setup_charge_commission_dict= {
                            "id":str(each_sub_payment_mode.id),
                            "subPaymentModeType": str(each_sub_payment_mode.subPaymentModeType),
                            "subPaymentModeId": str(each_sub_payment_mode.id),
                            "priceType": "",
                            "chargeType": "",
                            "chargeValue": 0,
                            "gstInclude": "",
                            "gstValue": 0,
                            "tdsInclude": "",
                            "tdsValue": 0,
                            "price_ranges": []
                        }

                    print("_____dict value",setup_charge_commission_dict)

                    setup_charge_commission_list.append(setup_charge_commission_dict)

                return render_template(
                    "super_admin_templates/merchant_setup_charge_commissions_list.html",
                    patternId=patternId,
                    patternsList=patternsList,
                    paymentModeId=paymentModeId,
                    paymentsModeList=paymentsModeList,
                    setup_charge_commission=setup_charge_commission,
                    subPaymentsModeList=subPaymentsModeList,
                    setup_charge_commission_list=setup_charge_commission_list,
                    # priceRangeList=price_ranges,
                    editable=editable,
                    update= update
                )

            return render_template("super_admin_templates/merchant_setup_charge_commissions_list.html",
                commissionsList=commissionsList,
                subPaymentsModeList=subPaymentsModeList,
                setup_charge_commission=setup_charge_commission,
                patternsList=patternsList,
                paymentsModeList=paymentsModeList,
                redirectval=redirectTo,
                error=error,
                editable=editable,
                success_message=success_message
            )

        except Exception as e:
            app.logger.error(traceback.format_exc())
            error = "Unable to fetch setup charge commission details!!"
            flash(error, "error")
            return render_template("super_admin_templates/merchant_setup_charge_commissions_list.html",commissionsList=commissionsList,
                subPaymentsModeList=subPaymentsModeList,
                setup_charge_commission=setup_charge_commission,
                patternsList=patternsList,
                paymentsModeList=paymentsModeList,
                redirectval=redirectTo,
                error=error,
                editable=editable,
                success_message=success_message
                )

@patterns_configuarations.route("/merchant_upsert_setup_charge_commission", methods=["POST"])
@adminid_access_token_required
def merchant_upsert_setup_charge_commission():
    if not session.get("adminId"):
        return redirect("admin_login")
    try:
        print(request.form,"request.form")
        patternId = request.form.get("patternId", "") # type: ignore
        paymentModeId = request.form.get("paymentModeId", "")
        subPaymentModeId = request.form.get("subPaymentModeId", "")
        priceType = request.form.get("priceType", "")
        gstInclude = request.form.get("gstInclude", "")
        gstValue = request.form.get("gstValue", 0)
        tdsInclude = request.form.get("tdsInclude", "")
        tdsValue = request.form.get("tdsValue", 0)
        chargeType = request.form.get("chargeType", "")
        chargeValue = request.form.get("chargeValue", 0)
        price_range_list = []
        priceDict={}
        if priceType == 'RANGE':
            startAmountListField = request.form.getlist("startAmount[]")
            endAmountListField = request.form.getlist("endAmount[]")
            chargeTypeListField = request.form.getlist("chargeType[]")
            chargeValueListField = request.form.getlist("chargeValue[]")

            if len(startAmountListField) == len(endAmountListField) == len(chargeTypeListField) == len(chargeValueListField):
                j=0
                for startAmount in startAmountListField:
                    isUnlimited=False
                    if len(startAmountListField)-1==j:
                       isUnlimited=True 
                    priceDict={
                    'startAmount': float(startAmount),
                    'endAmount': float(endAmountListField[j]),
                    'chargeType': chargeTypeListField[j],
                    'chargeValue': float(chargeValueListField[j]),
                    'isUnlimited':isUnlimited
                    }
                    price_range_list.append(priceDict)

                    j=j+1

        existing_record = SetupChargeCommissions.objects(paymentModeIdsList__in=[paymentModeId],
            subPaymentModeIdsList__in=[subPaymentModeId],patternIdsList__in=[patternId],status=1).first()
        if existing_record:
            existing_record.update(priceType=priceType,chargeType=chargeType,chargeValue=float(chargeValue),priceRangeList=price_range_list,gstInclude=gstInclude,gstValue=float(gstValue),tdsInclude=tdsInclude,tdsValue=float(tdsValue))
            flash("Record updated successfully!", "success")
        else:
            # print("is new record++++++++++++++++++++")
            new_record = SetupChargeCommissions(
                adminId=session.get("adminId"),
                patternIdsList=[ObjectId(patternId)],
                paymentModeIdsList=[ObjectId(paymentModeId)],
                subPaymentModeIdsList=[ObjectId(subPaymentModeId)],
                priceType=priceType,
                gstInclude=gstInclude,
                gstValue=float(gstValue),
                tdsInclude=tdsInclude,
                tdsValue=float(tdsValue),
                chargeType=chargeType,
                chargeValue=float(chargeValue),
                priceRangeList=price_range_list,
                createdOn=datetime.datetime.now(),
                status=1,
            )
            new_record.save()
            flash("Setup charge commission created successfully!", "success")

        return redirect(url_for("patterns_configuarations.get_merchant_setup_charge_commissions_list", patternId=patternId, paymentModeId=paymentModeId,action="search"))
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash(f"Error in upserting record: {str(e)}", "error")
        return redirect(url_for("patterns_configuarations.get_merchant_setup_charge_commissions_list"))
    
class GetServicePaymentSetupChargeCommission(FlaskForm):
    paymentModeId = SelectField('', choices=[],validate_choice=False , validators=[DataRequired(message="Payment Mode is required")])
    servicePaymentType = SelectField('', choices=["","bbps","digitalGold"] , validators=[DataRequired(message="Service Payment Type API is required")])

    class Meta:
        csrf = False


@patterns_configuarations.route("/get_service_payment_setup_charge_commission", methods=["POST", "GET"])
@adminid_access_token_required
def get_service_payment_setup_charge_commission():
    if not session.get("adminId"):
        return redirect("admin_login")
    # Initialize lists
    commissionsList = []
    paymentsModeList = []
    subPaymentsModeList = []
    error = None
    success_message = None
    editable = False
    update = False
    setup_charge_commission={}
    setup_charge_commission_dict={}
    setup_charge_commission_list=[]
    price_ranges = []
    servicePaymentType =""
    form = GetServicePaymentSetupChargeCommission(request.args)

    adminId = session.get("adminId")
    permissionsList = check_permissions(session.get("adminId"), "servicePaymentSetupChargeCommissionPermissions")
    if "view" in permissionsList:
        try:
            action = request.form.get("action", "").strip()
            data = request.form.to_dict()
            # Step 1: Handle OTP Generation
            # otp_check_id = request.form.get("otpLogid", "")
            # print("otp_check_id",otp_check_id)
            # if not otp_check_id:
            #     flash("Invalid Request.")
            #     return render_template("super_admin_templates/api_setup_charge_commissions_list.html")

            # otpcheck_queryset = OtpChecks.objects(adminId=adminId, id=str(otp_check_id), status=1).first()

            # if not otpcheck_queryset:
            #     flash("Invalid Request.")
            #     return render_template("super_admin_templates/api_setup_charge_commissions_list.html")
            # # Update OTP status to 2 after verification
            # otpcheck_queryset.update(status=2)

            redirectTo = request.args.get("redirectTo", "Commission")
            search_action = request.args.get("action")

            ######################## Common Lists ###########################



            payments_mod_queryset = PaymentMode.objects(status__in=[0, 1]).order_by("-id").all()
            for each_payment_mode in payments_mod_queryset:
                paymentsModeList.append(fetching_payment_mode_details(each_payment_mode))

         
            if request.method == "GET" and request.args.get("action") == "search":
                paymentModeId = request.args.get("paymentModeId")
                subPaymentModeId = request.args.get("subPaymentModeId")
                servicePaymentType = request.args.get("servicePaymentType")
                editable = True
                update = True

                # print(paymentModeId,"(((((((((paymentModeId)))))))))")
                # print(subPaymentModeId,"(((((((((subPaymentModeId)))))))))")
                # print(transactionAPIId,"(((((((((transactionAPIId)))))))))")

                # Search for matching records
                if form.validate():

                    sub_payments_mod_queryset = SubPaymentModes.objects(paymentModeId=paymentModeId,status__in=[0, 1]).order_by("-id").all()
                    for each_sub_payment_mode in sub_payments_mod_queryset:
                        setup_charge_commission_queryset = ServicePaymentSetupChargeCommission.objects(subPaymentModeIdsList__in=[str(each_sub_payment_mode.id)],
                        paymentModeIdsList__in=[paymentModeId],
                        servicePaymentType=servicePaymentType,
                        status=1).first()

                        if setup_charge_commission_queryset:
                            price_ranges=[]
                            if setup_charge_commission_queryset.priceType == 'RANGE':
                                price_ranges = setup_charge_commission_queryset.priceRangeList
                            setup_charge_commission_dict= {
                                "id":str(each_sub_payment_mode.id),
                                "servicePaymentType":servicePaymentType,
                                "subPaymentModeType": each_sub_payment_mode.subPaymentModeType,  # Use the subPaymentModeType
                                "subPaymentModeId": str(each_sub_payment_mode.id),  # Keep the ID for reference
                                "priceType": setup_charge_commission_queryset.priceType,
                                "chargeType": setup_charge_commission_queryset.chargeType,
                                "chargeValue": setup_charge_commission_queryset.chargeValue,
                                "gstInclude": setup_charge_commission_queryset.gstInclude,
                                "gstValue": setup_charge_commission_queryset.gstValue,
                                "tdsInclude": setup_charge_commission_queryset.tdsInclude,
                                "tdsValue": setup_charge_commission_queryset.tdsValue,
                                "price_ranges": price_ranges
                            }
                        else:
                            setup_charge_commission_dict= {
                                "id":str(each_sub_payment_mode.id),
                                "servicePaymentType":servicePaymentType,
                                "subPaymentModeType": str(each_sub_payment_mode.subPaymentModeType),
                                "subPaymentModeId": str(each_sub_payment_mode.id),
                                "priceType": "",
                                "chargeType": "",
                                "chargeValue": 0,
                                "gstInclude": "",
                                "gstValue": 0,
                                "tdsInclude": "",
                                "tdsValue": 0,
                                "price_ranges": []
                            }

                        # print("_____dict value",setup_charge_commission_dict)

                        setup_charge_commission_list.append(setup_charge_commission_dict)
                return render_template(
                    "super_admin_templates/service_payment_setup_charge_commission.html",
                    paymentModeId=paymentModeId,
                    paymentsModeList=paymentsModeList,
                    setup_charge_commission=setup_charge_commission,
                    subPaymentsModeList=subPaymentsModeList,
                    servicePaymentType=servicePaymentType,
                    setup_charge_commission_list=setup_charge_commission_list,
                    form = form,
                    # priceRangeList=price_ranges,
                    editable=editable,
                    update= update
                )

            return render_template("super_admin_templates/service_payment_setup_charge_commission.html",
                commissionsList=commissionsList,
                subPaymentsModeList=subPaymentsModeList,
                setup_charge_commission=setup_charge_commission,
                paymentsModeList=paymentsModeList,
                servicePaymentType=servicePaymentType,
                redirectval=redirectTo,
                error=error,
                form = form,
                editable=editable,
                success_message=success_message
            )

        except Exception as e:
            app.logger.error(traceback.format_exc())
            error = "Unable to fetch setup charge commission details!!"
            flash(error, "error")
            return render_template("super_admin_templates/service_payment_setup_charge_commission.html",commissionsList=commissionsList,
                subPaymentsModeList=subPaymentsModeList,
                setup_charge_commission=setup_charge_commission,
                paymentsModeList=paymentsModeList,
                redirectval=redirectTo,
                servicePaymentType=servicePaymentType,
                error=error,
                form = form,
                editable=editable,
                success_message=success_message
                )
    else:
        flash("The staff member does not have permission to view Service payment setup charge commission details.", "danger")
        return redirect(url_for("admin.dashboard"))
    



@patterns_configuarations.route("/service_payment_setup_charge_commission", methods=["POST","GET"])
@adminid_access_token_required
def service_payment_setup_charge_commission():
    data_status={"responseStatus":0,"result":""}
    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()

    try:
        print(request.form,"request.form")
        if request.method == "GET":
            return redirect(url_for("patterns_configuarations.get_service_payment_setup_charge_commission"))

        paymentModeId = request.form.get("paymentModeId", "")
        subPaymentModeId = request.form.get("subPaymentModeId", "")
        servicePaymentType = request.form.get("servicePaymentType", "")
        priceType = request.form.get("priceType", "")
        gstInclude = request.form.get("gstInclude", "")
        gstValue = request.form.get("gstValue", 0)
        tdsInclude = request.form.get("tdsInclude", "")
        tdsValue = request.form.get("tdsValue", 0)
        chargeType = request.form.get("chargeType", "")
        chargeValue = request.form.get("chargeValue", 0)
        price_range_list = []
        priceDict={}

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

        if priceType == 'RANGE':
            chargeType=""
            chargeValue=0
            startAmountListField = request.form.getlist("startAmount")
            endAmountListField = request.form.getlist("endAmount")
            chargeTypeListField = request.form.getlist("chargeTypeList")
            chargeValueListField = request.form.getlist("chargeValueList")

            print("((((((((((startAmountListField))))))))))",startAmountListField)
            print("((((((((((endAmountListField))))))))))",endAmountListField)

            

            # def has_negative(values):
            #     for v in values:
            #         try:
            #             if float(v) < 0:
            #                 return True
            #         except ValueError:
            #             # Handle non-numeric inputs if needed
            #             pass
            #     return False

            # if has_negative(startAmountListField):
            #     flash("startAmount cannot have negative Values")
            # if has_negative(endAmountListField):
            #     flash("endAmount cannot have negative Values")
            # if has_negative(chargeValueListField):
            #     flash("chargeValueListField has negative value")
            # return redirect(url_for("patterns_configuarations.get_api_setup_charge_commissions_list"))

            print("(((((((((((((((range list)))))))))))))))",startAmountListField,endAmountListField,chargeTypeListField,chargeValueListField)
            is_valid, error_list = validate_api_setup_charges_list(
            startAmountListField=startAmountListField,
            endAmountListField=endAmountListField,
            chargeTypeListField=chargeTypeListField,
            chargeValueListField=chargeValueListField
            )
            j = 0
            if is_valid:
                for startAmount in startAmountListField:
                    isUnlimited=False
                    if len(startAmountListField)-1==j:
                        isUnlimited=True 
                    priceDict={
                    'startAmount': float(startAmount) if startAmount else 0.0,
                    'endAmount': float(endAmountListField[j]) if endAmountListField[j] else 0.0,
                    'chargeType': chargeTypeListField[j],
                    'chargeValue': float(chargeValueListField[j]) if chargeValueListField[j] else 0.0,
                    'isUnlimited':isUnlimited
                    }
                    price_range_list.append(priceDict)

                    j=j+1
            else:
                print("form errors",error_list)
                data_status["responseStatus"]=0
                data_status["result"]=error_list
                return data_status
        
        form = ApiUpsertSetupChargeCommissionForm()
        if form.validate_on_submit():

            existing_record = ServicePaymentSetupChargeCommission.objects(paymentModeIdsList__in=[paymentModeId],
                subPaymentModeIdsList__in=[subPaymentModeId],servicePaymentType=servicePaymentType,status=1).first()
            if existing_record:
                existing_record.update(priceType=priceType,chargeType=chargeType,chargeValue=float(chargeValue),priceRangeList=price_range_list,gstInclude=gstInclude,gstValue=float(gstValue),tdsInclude=tdsInclude,tdsValue=float(tdsValue))
                flash("Record updated successfully!", "success")
            else:
                admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                if admin_queryset:
                    message=admin_queryset.userName+" Service Payment Setup charge commission created successfully!"
                    save_admin_log_table = save_admin_logs_data(adminId,None,None,"service_payment_setup_charge_commission","create",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 
                # print("is new record++++++++++++++++++++")
                new_record = ServicePaymentSetupChargeCommission(
                    adminId=session.get("adminId"),
                    paymentModeIdsList=[ObjectId(paymentModeId)],
                    servicePaymentType=servicePaymentType,
                    subPaymentModeIdsList=[ObjectId(subPaymentModeId)],
                    priceType=priceType,
                    gstInclude=gstInclude,
                    gstValue=float(gstValue) if gstValue else 0.0,
                    tdsInclude=tdsInclude,
                    tdsValue=float(tdsValue) if gstValue else 0.0,
                    chargeType=chargeType,
                    chargeValue=float(chargeValue) if gstValue else 0.0,
                    priceRangeList=price_range_list,
                    createdOn=datetime.datetime.now(),
                    status=1,
                )
                new_record.save()
                flash("Setup charge commission created successfully!", "success")

            data_status['responseStatus']=1
            return data_status
        else:
            data_status['result']=form.errors
            return data_status
    except Exception as e:
        flash(f"Error in upserting record: {str(e)}", "error")
        app.logger.error(traceback.format_exc())
        data_status['responseStatus']=4
        return data_status
  

@patterns_configuarations.route("/get_api_setup_charge_commissions_list", methods=["POST", "GET"])
@adminid_access_token_required
def get_api_setup_charge_commissions_list():
    if not session.get("adminId"):
        return redirect("admin_login")
    # Initialize lists
    commissionsList = []
    transactionAPIsList = []
    paymentsModeList = []
    subPaymentsModeList = []
    error = None
    success_message = None
    editable = False
    update = False
    setup_charge_commission={}
    setup_charge_commission_dict={}
    setup_charge_commission_list=[]
    price_ranges = []
    transactionapiName=""
    form = GetApiSetupChargeCommissionListFormList(request.args)

    adminId = session.get("adminId")
    permissionsList = check_permissions(session.get("adminId"), "apiSetupChargeCommissionslistPermissions")
    if "view" in permissionsList:
        try:
            action = request.form.get("action", "").strip()
            data = request.form.to_dict()
            # Step 1: Handle OTP Generation
            # otp_check_id = request.form.get("otpLogid", "")
            # print("otp_check_id",otp_check_id)
            # if not otp_check_id:
            #     flash("Invalid Request.")
            #     return render_template("super_admin_templates/api_setup_charge_commissions_list.html")

            # otpcheck_queryset = OtpChecks.objects(adminId=adminId, id=str(otp_check_id), status=1).first()

            # if not otpcheck_queryset:
            #     flash("Invalid Request.")
            #     return render_template("super_admin_templates/api_setup_charge_commissions_list.html")
            # # Update OTP status to 2 after verification
            # otpcheck_queryset.update(status=2)

            redirectTo = request.args.get("redirectTo", "Commission")
            search_action = request.args.get("action")

            ######################## Common Lists ###########################
            transaction_API_queryset = TransactionAPI.objects(status__in=[0, 1]).order_by('-id').all()
            for each_transaction_api in transaction_API_queryset:
                service_grouping_dict = {
                    "id": str(each_transaction_api.id),
                    "apiName": each_transaction_api.apiName
                }
                transactionAPIsList.append(service_grouping_dict)


            payments_mod_queryset = PaymentMode.objects(status__in=[0, 1]).order_by("-id").all()
            for each_payment_mode in payments_mod_queryset:
                paymentsModeList.append(fetching_payment_mode_details(each_payment_mode))

         
            if request.method == "GET" and request.args.get("action") == "search":
                paymentModeId = request.args.get("paymentModeId")
                subPaymentModeId = request.args.get("subPaymentModeId")
                transactionAPIId = request.args.get("transactionAPIId")
                editable = True
                update = True

                # print(paymentModeId,"(((((((((paymentModeId)))))))))")
                # print(subPaymentModeId,"(((((((((subPaymentModeId)))))))))")
                # print(transactionAPIId,"(((((((((transactionAPIId)))))))))")

                # Search for matching records
                if form.validate():

                    transaction_queryset = TransactionAPI.objects(id=str(transactionAPIId)).first()
                    if transaction_queryset:
                        transactionapiName=transaction_queryset.apiName

                    sub_payments_mod_queryset = SubPaymentModes.objects(paymentModeId=paymentModeId,status__in=[0, 1]).order_by("-id").all()
                    for each_sub_payment_mode in sub_payments_mod_queryset:
                        setup_charge_commission_queryset = ApiSetupChargeCommissions.objects(paymentModeIdsList__in=[paymentModeId],subPaymentModeIdsList__in=[str(each_sub_payment_mode.id)],
                        transactionAPIIdsList__in=[transactionAPIId],
                        status=1).first()

                        if setup_charge_commission_queryset:
                            price_ranges=[]
                            if setup_charge_commission_queryset.priceType == 'RANGE':
                                price_ranges = setup_charge_commission_queryset.priceRangeList
                            setup_charge_commission_dict= {
                                "id":str(setup_charge_commission_queryset.id),
                                "subPaymentModeType": each_sub_payment_mode.subPaymentModeType,  # Use the subPaymentModeType
                                "subPaymentModeId": str(each_sub_payment_mode.id),  # Keep the ID for reference
                                "priceType": setup_charge_commission_queryset.priceType,
                                "chargeType": setup_charge_commission_queryset.chargeType,
                                "chargeValue": setup_charge_commission_queryset.chargeValue,
                                "gstInclude": setup_charge_commission_queryset.gstInclude,
                                "gstValue": setup_charge_commission_queryset.gstValue,
                                "tdsInclude": setup_charge_commission_queryset.tdsInclude,
                                "tdsValue": setup_charge_commission_queryset.tdsValue,
                                "price_ranges": price_ranges
                            }
                        else:
                            # new_record = ApiSetupChargeCommissions(
                            #     paymentModeIdsList=[ObjectId(paymentModeId)],
                            #     transactionAPIIdsList=[ObjectId(transactionAPIId)],
                            #     subPaymentModeIdsList=[ObjectId(subPaymentModeId)],
                            #     priceType=priceType,
                            #     gstInclude=gstInclude,
                            #     gstValue=float(gstValue) if gstValue else 0.0,
                            #     tdsInclude=tdsInclude,
                            #     tdsValue=float(tdsValue) if gstValue else 0.0,
                            #     chargeType=chargeType,
                            #     chargeValue=float(chargeValue) if gstValue else 0.0,
                            #     priceRangeList=price_range_list,
                            #     createdOn=datetime.datetime.now(),
                            #     status=1,
                            # )
                            setup_charge_commission_dict= {
                                "id":str(each_sub_payment_mode.id), # doubt about id
                                "subPaymentModeType": str(each_sub_payment_mode.subPaymentModeType),
                                "subPaymentModeId": str(each_sub_payment_mode.id),
                                "priceType": "",
                                "chargeType": "",
                                "chargeValue": 0,
                                "gstInclude": "",
                                "gstValue": 0,
                                "tdsInclude": "",
                                "tdsValue": 0,
                                "price_ranges": []
                            }

                        # print("_____dict value",setup_charge_commission_dict)

                        setup_charge_commission_list.append(setup_charge_commission_dict)
                return render_template(
                    "super_admin_templates/api_setup_charge_commissions_list.html",
                    paymentModeId=paymentModeId,
                    paymentsModeList=paymentsModeList,
                    transactionAPIId=transactionAPIId,
                    transactionapiName=transactionapiName,
                    transactionAPIsList=transactionAPIsList,
                    setup_charge_commission=setup_charge_commission,
                    subPaymentsModeList=subPaymentsModeList,
                    setup_charge_commission_list=setup_charge_commission_list,
                    form = form,
                    # priceRangeList=price_ranges,
                    editable=editable,
                    update= update
                )

            return render_template("super_admin_templates/api_setup_charge_commissions_list.html",
                commissionsList=commissionsList,
                subPaymentsModeList=subPaymentsModeList,
                setup_charge_commission=setup_charge_commission,
                paymentsModeList=paymentsModeList,
                transactionapiName=transactionapiName,
                transactionAPIsList=transactionAPIsList,
                redirectval=redirectTo,
                error=error,
                form = form,
                editable=editable,
                success_message=success_message
            )

        except Exception as e:
            app.logger.error(traceback.format_exc())
            error = "Unable to fetch setup charge commission details!!"
            flash(error, "error")
            return render_template("super_admin_templates/api_setup_charge_commissions_list.html",commissionsList=commissionsList,
                subPaymentsModeList=subPaymentsModeList,
                setup_charge_commission=setup_charge_commission,
                paymentsModeList=paymentsModeList,
                transactionAPIsList=transactionAPIsList,
                transactionapiName=transactionapiName,
                redirectval=redirectTo,
                error=error,
                form = form,
                editable=editable,
                success_message=success_message
                )
    else:
        flash("The staff member does not have permission to view Api setup charge commission details.", "danger")
        return redirect(url_for("admin.dashboard"))
    


# @patterns_configuarations.route("/api_upsert_setup_charge_commission", methods=["POST","GET"])
# @adminid_access_token_required
# @csrf_protect
# def api_upsert_setup_charge_commission():
#     data_status={"responseStatus":0,"result":""}
#     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()
#     try:
#         print(request.form,"request.form")
#         if request.method == "GET":
#             return redirect(url_for("patterns_configuarations.get_api_setup_charge_commissions_list"))

#         paymentModeId = request.form.get("paymentModeId", "")
#         subPaymentModeId = request.form.get("subPaymentModeId", "")
#         transactionAPIId = request.form.get("transactionAPIId", "")
#         priceType = request.form.get("priceType", "")
#         gstInclude = request.form.get("gstInclude", "")
#         gstValue = request.form.get("gstValue", 0)
#         tdsInclude = request.form.get("tdsInclude", "")
#         tdsValue = request.form.get("tdsValue", 0)
#         chargeType = request.form.get("chargeType", "")
#         chargeValue = request.form.get("chargeValue", 0)
#         price_range_list = []
#         priceDict={}

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

#         data = request.form.to_dict()
               
                
#         otp_check_id = request.form.get("otpLogid", "")
#         defaultVerificationId = request.form.get("defaultVerificationId", "")
#         print("otp_check_id",otp_check_id)
#         if not otp_check_id:
#             flash("Invalid Request.")
#             data_status["responseStatus"]=4
#             return data_status

#         otpcheck_queryset = OtpChecks.objects(adminId=adminId,defaultVerificationField=defaultVerificationId, id=str(otp_check_id), status=1).first()

#         if not otpcheck_queryset:
#             flash("Invalid Request.")
#             data_status["responseStatus"]=4
#             return data_status

#         if priceType == 'RANGE':
#             chargeType=""
#             chargeValue=0
#             startAmountListField = request.form.getlist("startAmount")
#             endAmountListField = request.form.getlist("endAmount")
#             chargeTypeListField = request.form.getlist("chargeTypeList")
#             chargeValueListField = request.form.getlist("chargeValueList")

            

#             # def has_negative(values):
#             #     for v in values:
#             #         try:
#             #             if float(v) < 0:
#             #                 return True
#             #         except ValueError:
#             #             # Handle non-numeric inputs if needed
#             #             pass
#             #     return False

#             # if has_negative(startAmountListField):
#             #     flash("startAmount cannot have negative Values")
#             # if has_negative(endAmountListField):
#             #     flash("endAmount cannot have negative Values")
#             # if has_negative(chargeValueListField):
#             #     flash("chargeValueListField has negative value")
#             # return redirect(url_for("patterns_configuarations.get_api_setup_charge_commissions_list"))

#             print("(((((((((((((((range list)))))))))))))))",startAmountListField,endAmountListField,chargeTypeListField,chargeValueListField)

#             if len(startAmountListField) == len(endAmountListField) == len(chargeTypeListField) == len(chargeValueListField):

#                 for i in range(len(startAmountListField)-1):
#                     if float(startAmountListField[ i + 1 ]) - float(endAmountListField[ i ]) > 0.10:
#                         data_status['responseStatus']=2
#                         data_status['result']="Start amount must not differ from previous end amount by more than 0.1."
#                         return data_status

#                 j=0
#                 for startAmount in startAmountListField:


#                     isUnlimited=False
#                     if len(startAmountListField)-1==j:
#                         isUnlimited=True 
#                     priceDict={
#                     'startAmount': float(startAmount) if startAmount else 0.0,
#                     'endAmount': float(endAmountListField[j]) if endAmountListField[j] else 0.0,
#                     'chargeType': chargeTypeListField[j],
#                     'chargeValue': float(chargeValueListField[j]) if chargeValueListField[j] else 0.0,
#                     'isUnlimited':isUnlimited
#                     }
#                     price_range_list.append(priceDict)

#                     j=j+1
#             else:
#                 app.logger.error("range fields rows do not have same length")
#                 flash(f"Error in upserting record!")
#                 data_status['responseStatus']=4
#                 return data_status
        
#         form = ApiUpsertSetupChargeCommissionForm()
#         if form.validate_on_submit():

#             existing_record = ApiSetupChargeCommissions.objects(paymentModeIdsList__in=[paymentModeId],
#                 subPaymentModeIdsList__in=[subPaymentModeId],transactionAPIIdsList__in=[transactionAPIId],status=1).first()
#             if existing_record:
#                 existing_record.update(priceType=priceType,chargeType=chargeType,chargeValue=float(chargeValue),priceRangeList=price_range_list,gstInclude=gstInclude,gstValue=float(gstValue),tdsInclude=tdsInclude,tdsValue=float(tdsValue))
#                 flash("Record updated successfully!", "success")
#             else:
#                 admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
#                 if admin_queryset:
#                     message=admin_queryset.userName+" Api Setup charge commission created successfully!"
#                     save_admin_log_table = save_admin_logs_data(adminId,None,None,"api_upsert_setup_charge_commission","create",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 
#                 # print("is new record++++++++++++++++++++")
#                 new_record = ApiSetupChargeCommissions(
#                     adminId=session.get("adminId"),
#                     paymentModeIdsList=[ObjectId(paymentModeId)],
#                     transactionAPIIdsList=[ObjectId(transactionAPIId)],
#                     subPaymentModeIdsList=[ObjectId(subPaymentModeId)],
#                     priceType=priceType,
#                     gstInclude=gstInclude,
#                     gstValue=float(gstValue) if gstValue else 0.0,
#                     tdsInclude=tdsInclude,
#                     tdsValue=float(tdsValue) if gstValue else 0.0,
#                     chargeType=chargeType,
#                     chargeValue=float(chargeValue) if gstValue else 0.0,
#                     priceRangeList=price_range_list,
#                     createdOn=datetime.datetime.now(),
#                     status=1,
#                 )
#                 new_record.save()
#                 flash("Setup charge commission created successfully!", "success")

#             data_status['responseStatus']=1
#             return data_status
#         else:
#             data_status['result']=form.errors
#             return data_status
#     except Exception as e:
#         flash(f"Error in upserting record: {str(e)}", "error")
#         app.logger.error(traceback.format_exc())
#         data_status['responseStatus']=4
#         return data_status



@patterns_configuarations.route("/api_upsert_setup_charge_commission", methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def api_upsert_setup_charge_commission():
    data_status={"responseStatus":0,"result":""}
    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()
    try:
        print(request.form,"request.form")
        if request.method == "GET":
            return redirect(url_for("patterns_configuarations.get_api_setup_charge_commissions_list"))

        paymentModeId = request.form.get("paymentModeId", "")
        subPaymentModeId = request.form.get("subPaymentModeId", "")
        transactionAPIId = request.form.get("transactionAPIId", "")
        priceType = request.form.get("priceType", "")
        gstInclude = request.form.get("gstInclude", "")
        gstValue = request.form.get("gstValue", 0)
        tdsInclude = request.form.get("tdsInclude", "")
        tdsValue = request.form.get("tdsValue", 0)
        chargeType = request.form.get("chargeType", "")
        chargeValue = request.form.get("chargeValue", 0)
        price_range_list = []
        priceDict={}

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

        data = request.form.to_dict()
               
                
        otp_check_id = request.form.get("otpLogid", "")
        defaultVerificationId = request.form.get("defaultVerificationId", "")
        print("otp_check_id",otp_check_id)
        if not otp_check_id:
            flash("Invalid Request.")
            data_status["responseStatus"]=4
            return data_status

        otpcheck_queryset = OtpChecks.objects(adminId=adminId,defaultVerificationField=defaultVerificationId, id=str(otp_check_id), status=1).first()

        if not otpcheck_queryset:
            flash("Invalid Request.")
            data_status["responseStatus"]=4
            return data_status

        if priceType == 'RANGE':
            chargeType=""
            chargeValue=0
            startAmountListField = request.form.getlist("startAmount")
            endAmountListField = request.form.getlist("endAmount")
            chargeTypeListField = request.form.getlist("chargeTypeList")
            chargeValueListField = request.form.getlist("chargeValueList")

            

            # def has_negative(values):
            #     for v in values:
            #         try:
            #             if float(v) < 0:
            #                 return True
            #         except ValueError:
            #             # Handle non-numeric inputs if needed
            #             pass
            #     return False

            # if has_negative(startAmountListField):
            #     flash("startAmount cannot have negative Values")
            # if has_negative(endAmountListField):
            #     flash("endAmount cannot have negative Values")
            # if has_negative(chargeValueListField):
            #     flash("chargeValueListField has negative value")
            # return redirect(url_for("patterns_configuarations.get_api_setup_charge_commissions_list"))

            print("(((((((((((((((range list)))))))))))))))",startAmountListField,endAmountListField,chargeTypeListField,chargeValueListField)
            is_valid, error_list = validate_api_setup_charges_list(
            startAmountListField=startAmountListField,
            endAmountListField=endAmountListField,
            chargeTypeListField=chargeTypeListField,
            chargeValueListField=chargeValueListField
            )
            j = 0
            if is_valid:
                for startAmount in startAmountListField:


                    isUnlimited=False
                    if len(startAmountListField)-1==j:
                        isUnlimited=True 
                    priceDict={
                    'startAmount': float(startAmount) if startAmount else 0.0,
                    'endAmount': float(endAmountListField[j]) if endAmountListField[j] else 0.0,
                    'chargeType': chargeTypeListField[j],
                    'chargeValue': float(chargeValueListField[j]) if chargeValueListField[j] else 0.0,
                    'isUnlimited':isUnlimited
                    }
                    price_range_list.append(priceDict)

                    j=j+1
            else:
                print("form errors",error_list)
                data_status["responseStatus"]=0
                data_status["result"]=error_list
                return data_status
                


        form = ApiUpsertSetupChargeCommissionForm()
        if form.validate_on_submit():

            existing_record = ApiSetupChargeCommissions.objects(paymentModeIdsList__in=[paymentModeId],
                subPaymentModeIdsList__in=[subPaymentModeId],transactionAPIIdsList__in=[transactionAPIId],status=1).first()
            if existing_record:
                existing_record.update(priceType=priceType,chargeType=chargeType,chargeValue=float(chargeValue),priceRangeList=price_range_list,gstInclude=gstInclude,gstValue=float(gstValue),tdsInclude=tdsInclude,tdsValue=float(tdsValue))
                flash("Record updated successfully!", "success")
            else:
                admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                if admin_queryset:
                    message=admin_queryset.userName+" Api Setup charge commission created successfully!"
                    save_admin_log_table = save_admin_logs_data(adminId,None,None,"api_upsert_setup_charge_commission","create",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 
                # print("is new record++++++++++++++++++++")
                new_record = ApiSetupChargeCommissions(
                    adminId=session.get("adminId"),
                    paymentModeIdsList=[ObjectId(paymentModeId)],
                    transactionAPIIdsList=[ObjectId(transactionAPIId)],
                    subPaymentModeIdsList=[ObjectId(subPaymentModeId)],
                    priceType=priceType,
                    gstInclude=gstInclude,
                    gstValue=float(gstValue) if gstValue else 0.0,
                    tdsInclude=tdsInclude,
                    tdsValue=float(tdsValue) if gstValue else 0.0,
                    chargeType=chargeType,
                    chargeValue=float(chargeValue) if gstValue else 0.0,
                    priceRangeList=price_range_list,
                    createdOn=datetime.datetime.now(),
                    status=1,
                )
                new_record.save()
                flash("Setup charge commission created successfully!", "success")

            data_status['responseStatus']=1
            return data_status
        else:
            data_status['result']=form.errors
            return data_status
    except Exception as e:
        flash(f"Error in upserting record: {str(e)}", "error")
        app.logger.error(traceback.format_exc())
        data_status['responseStatus']=4
        return data_status


            

# @patterns_configuarations.route("/api_upsert_setup_charge_commission", methods=["POST","GET"])
# @adminid_access_token_required
# def api_upsert_setup_charge_commission():
#     if not session.get("adminId"):
#         return redirect("admin_login")
#     try:
#         print(request.form,"request.form")
#         if request.method == "GET":
#             return redirect(url_for("patterns_configuarations.get_api_setup_charge_commissions_list"))

#         paymentModeId = request.form.get("paymentModeId", "")
#         subPaymentModeId = request.form.get("subPaymentModeId", "")
#         transactionAPIId = request.form.get("transactionAPIId", "")
#         priceType = request.form.get("priceType", "")
#         gstInclude = request.form.get("gstInclude", "")
#         gstValue = request.form.get("gstValue", 0)
#         tdsInclude = request.form.get("tdsInclude", "")
#         tdsValue = request.form.get("tdsValue", 0)
#         chargeType = request.form.get("chargeType", "")
#         chargeValue = request.form.get("chargeValue", 0)
#         price_range_list = []
#         priceDict={}
#         if priceType == 'RANGE':
#             chargeType=""
#             chargeValue=0
#             startAmountListField = request.form.getlist("startAmount[]")
#             endAmountListField = request.form.getlist("endAmount[]")
#             chargeTypeListField = request.form.getlist("chargeTypeList[]")
#             chargeValueListField = request.form.getlist("chargeValueList[]")

#             def has_negative(values):
#                 for v in values:
#                     try:
#                         if float(v) < 0:
#                             return True
#                     except ValueError:
#                         # Handle non-numeric inputs if needed
#                         pass
#                 return False

#             if has_negative(startAmountListField):
#                 flash("startAmount cannot have negative Values")
#             if has_negative(endAmountListField):
#                 flash("endAmount cannot have negative Values")
#             if has_negative(chargeValueListField):
#                 flash("chargeValueListField has negative value")
#             return redirect(url_for("patterns_configuarations.get_api_setup_charge_commissions_list"))

#             # print("(((((((((((((((range list)))))))))))))))",startAmountListField,endAmountListField,chargeTypeListField,chargeValueListField)

#             if len(startAmountListField) == len(endAmountListField) == len(chargeTypeListField) == len(chargeValueListField):
#                 j=0
#                 for startAmount in startAmountListField:
#                     isUnlimited=False
#                     if len(startAmountListField)-1==j:
#                        isUnlimited=True 
#                     priceDict={
#                     'startAmount': float(startAmount),
#                     'endAmount': float(endAmountListField[j]),
#                     'chargeType': chargeTypeListField[j],
#                     'chargeValue': float(chargeValueListField[j]),
#                     'isUnlimited':isUnlimited
#                     }
#                     price_range_list.append(priceDict)

#                     j=j+1
#             else:
#                 app.logger.error("range fields rows do not have same length")
#                 flash(f"Error in upserting record!")
#                 return redirect(url_for("patterns_configuarations.get_api_setup_charge_commissions_list"))

#         existing_record = ApiSetupChargeCommissions.objects(paymentModeIdsList__in=[paymentModeId],
#             subPaymentModeIdsList__in=[subPaymentModeId],transactionAPIIdsList__in=[transactionAPIId],status=1).first()
#         if existing_record:
#             existing_record.update(priceType=priceType,chargeType=chargeType,chargeValue=float(chargeValue),priceRangeList=price_range_list,gstInclude=gstInclude,gstValue=float(gstValue),tdsInclude=tdsInclude,tdsValue=float(tdsValue))
#             flash("Record updated successfully!", "success")
#         else:
#             # print("is new record++++++++++++++++++++")
#             new_record = ApiSetupChargeCommissions(
#                 adminId=session.get("adminId"),
#                 paymentModeIdsList=[ObjectId(paymentModeId)],
#                 transactionAPIIdsList=[ObjectId(transactionAPIId)],
#                 subPaymentModeIdsList=[ObjectId(subPaymentModeId)],
#                 priceType=priceType,
#                 gstInclude=gstInclude,
#                 gstValue=float(gstValue),
#                 tdsInclude=tdsInclude,
#                 tdsValue=float(tdsValue),
#                 chargeType=chargeType,
#                 chargeValue=float(chargeValue),
#                 priceRangeList=price_range_list,
#                 createdOn=datetime.datetime.now(),
#                 status=1,
#             )
#             new_record.save()
#             flash("Setup charge commission created successfully!", "success")

#         return redirect(url_for("patterns_configuarations.get_api_setup_charge_commissions_list", paymentModeId=paymentModeId,transactionAPIId=transactionAPIId,action="search"))
#     except Exception as e:
#         app.logger.error(traceback.format_exc())
#         flash(f"Error in upserting record: {str(e)}", "error")
#         return redirect(url_for("patterns_configuarations.get_api_setup_charge_commissions_list"))

@patterns_configuarations.route("/bulk_profile_update",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def bulk_profile_update():
    data_status = {"responseStatus": 0, "result": ""}
    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()

    existingPatternsList = []
    form = BulkProfileUpdateForm(request.form)
    try:
        permissionsList = check_permissions(session.get("adminId"),"bulkprofileupdatePermissions")
        if "edit" in permissionsList:
            if request.method =="GET":

                user_queryset = Patterns.objects(status__in=[0,1]).all()
                for each_user in user_queryset:
                    patternDict = {
                        "patternId":each_user.id,
                        "patternName":each_user.name
                    }
                    if patternDict not in existingPatternsList:
                        existingPatternsList.append(patternDict)
                return render_template(
                        "super_admin_templates/bulk_profile_update.html",
                        existingPatternsList=existingPatternsList
                    )
            elif request.method=="POST":
                if form.validate_on_submit():
                    otp_check_id = request.form.get("otpLogid", "")
                    defaultVerificationId = request.form.get("defaultVerificationId", "")

                    print("otp_check_id",otp_check_id)
                    if not otp_check_id:
                        flash("Invalid Request.")
                        return redirect(url_for("patterns_configuarations.bulk_profile_update"))
                    
                    otpcheck_queryset = OtpChecks.objects(adminId=adminId,defaultVerificationField=defaultVerificationId,id=str(otp_check_id), status=1).first()
                    
                    if not otpcheck_queryset:
                        flash("Invalid Request.")
                        return redirect(url_for("patterns_configuarations.bulk_profile_update"))
                    # Update OTP status to 2 after verification
                    otpcheck_queryset.update(status=2)
    
                

                    updateType=""
                    existingPatternIdsList = request.form.getlist("existingPatternIdsList")
                    newPatternId = request.form.get("newPatternId")
                    includeUsersList = request.form.getlist("includeUsersList")
                    excludeUsersList = request.form.getlist("excludeUsersList")

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

                    if len(includeUsersList)> 0:
                        updateType="include"
                    elif len(excludeUsersList)> 0:
                        updateType="exclude"
                    
                    if existingPatternIdsList and newPatternId:
                        users_queryset=Users.objects(patternId__in=existingPatternIdsList,status=1).all()
                        admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                        existing_record = users_queryset.to_json()
                        message=admin_queryset.userName+" Switch User profile updated successfully!"
                        requestData=[users_queryset]
                        updatedrequestData=[jsonData]
                        save_admin_log_table = save_admin_logs_data(adminId,None,None,"bulk_profile_update","update",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)

                        users_count=0
                        for user in users_queryset:
                            if updateType == "include":
                                if str(user.id) in includeUsersList:
                                    users_count= users_count+1
                                    user.patternId = ObjectId(newPatternId)
                                    user.save()
                            elif updateType == "exclude":
                                if str(user.id) not in excludeUsersList:
                                    users_count= users_count+1
                                    user.patternId = ObjectId(newPatternId)
                                    user.save()
                            else:
                                users_count= users_count+1
                                user.patternId = ObjectId(newPatternId)
                                user.save()
                        if users_count > 0:
                            flash("User profile updated successfully for "+str(users_count)+" Users!!")
                            data_status["responseStatus"]=1
                            return data_status

                        else:
                            flash("No Users with selected Profile exist!!")
                            data_status["responseStatus"]=1
                            return data_status
                    else:
                        flash("Required fields are missing!!")
                        data_status["responseStatus"]=4
                        return data_status
                else:
                    print("form errors",form.errors)
                    data_status["result"]=form.errors
                    return data_status
        else:
            flash("The staff member does not have permission to update Bulk profile.", "danger")
            data_status["responseStatus"]=4
            return data_status
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash(f"Error in Bulk Profile Update: {str(e)}", "error")
        data_status["responseStatus"]=4
        return data_status
        
                
@patterns_configuarations.route("/get_profile_users_list",methods=["POST","GET"])
@adminid_access_token_required
@csrf.exempt
def get_profile_users_list():
    try:
        data_status = {"responseStatus": 0, "result": ""}
        if not session.get("adminId"):
            return redirect("admin_login")
        adminId=session.get("adminId")

        patternIdsList = request.json.get("patternIds")
        patternUsersList = []

        users_queryset=Users.objects(patternId__in=patternIdsList,status=1).all()
        for user in users_queryset:
            userDict = {
                "id": str(user.id),
                "fullName": user.fullName,
                "merchantReferenceNumber": user.merchantUniqueNumber,
                "phoneNumber": user.phoneNumber,
            }
            patternUsersList.append(userDict)

        data_status["responseStatus"] = 1
        data_status["result"] = "ProfileUsers List fetched successfully!"
        data_status["patternUsersList"] = patternUsersList

        return jsonify(data_status), 200
        return redirect(url_for("patterns_configuarations.bulk_profile_update"))

    except Exception as e:
        app.logger.error(traceback.format_exc())
        data_status["result"] = "An error occurred while fetching payout options!"
        return jsonify(data_status), 500


def validate_available_timings(
    transactionType, is_enabled,
    sun_enabled, sun_from_times, sun_to_times,
    mon_enabled, mon_from_times, mon_to_times,
    tue_enabled, tue_from_times, tue_to_times,
    wed_enabled, wed_from_times, wed_to_times,
    thu_enabled, thu_from_times, thu_to_times,
    fri_enabled, fri_from_times, fri_to_times,
    sat_enabled, sat_from_times, sat_to_times
):
    errors = {}
    if not transactionType:
        errors["transactionType"] = "Transaction type is required."

    days = {
        "Sunday": (sun_enabled, sun_from_times, sun_to_times),
        "Monday": (mon_enabled, mon_from_times, mon_to_times),
        "Tuesday": (tue_enabled, tue_from_times, tue_to_times),
        "Wednesday": (wed_enabled, wed_from_times, wed_to_times),
        "Thursday": (thu_enabled, thu_from_times, thu_to_times),
        "Friday": (fri_enabled, fri_from_times, fri_to_times),
        "Saturday": (sat_enabled, sat_from_times, sat_to_times),
    }

    for day, (enabled, from_list, to_list) in days.items():
        if enabled:
            if not from_list or not to_list:
                errors[f"{day}"] = f"{day} timings are missing."
                continue

            if len(from_list) != len(to_list):
                errors[f"{day}_length"] = f"{day} has mismatched from/to times."
                continue
            seen_slots = set()
            for i, (from_time, to_time) in enumerate(zip(from_list, to_list)):
                if not from_time.strip():
                    errors[f"{day}_from_{i}"] = f"Missing from time for {day}, slot {i+1}."
                if not to_time.strip():
                    errors[f"{day}_to_{i}"] = f"Missing to time for {day}, slot {i+1}."
                if from_time and to_time:
                    if from_time >= to_time:
                        errors[f"{day}_order_{i}"] = f"'From' time must be earlier than 'To' time on {day}, slot {i+1}."
                    
                    time_pair = (from_time, to_time)
                    if time_pair in seen_slots:
                        errors[f"{day}_duplicate_{i}"] = f"Duplicate time slot on {day}, slot {i+1}: {from_time} - {to_time}."
                    else:
                        seen_slots.add(time_pair)
    print("len()",len(errors) == 0)
    print("lenaaaaaaaaaaaaaaaaa",errors)
    return (len(errors) == 0), errors

@patterns_configuarations.route("/available_timings",methods=["POST","GET"])
@adminid_access_token_required
def available_timings():
    try:
        data_status = {"responseStatus": 0, "result":""}
        payinTimingsList=[]
        available_timings_data={}

        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()
        transactionType =request.args.get("transactionType","")
        redirectTo =request.args.get("redirectval","timingsList")
        print("(((((((((((redirect)))))))))))", redirectTo)

        permissionsList = check_permissions(session.get("adminId"),"payinAvailableTimePermissions")
        if "view" in permissionsList:


            available_timings_queryset0 = AvailableTimings.objects(transactionType=transactionType,status=1).first()
            available_timings_data_list=[]
            overridesDatesList = []
            timings_str_list=[]
            overrideTimingsList=[]
            # If the record doesn't exist, create a new one
            if not available_timings_queryset0:
                available_timings_queryset1 = AvailableTimings(
                    isEnabled =  False,
                    sunEnabled = False,
                    sunAvailableTimingsList = [],
                    monEnabled = False,
                    monAvailableTimingsList = [],
                    tueEnabled = False,
                    tueAvailableTimingsList = [],
                    wedEnabled = False,
                    wedAvailableTimingsList = [],
                    thuEnabled = False,
                    thuAvailableTimingsList = [],
                    friEnabled = False,
                    friAvailableTimingsList = [],
                    satEnabled = False,
                    satAvailableTimingsList = [],
                    overridesDatesList = [],
                    transactionType=transactionType,  # Ensure it's for "payout"
                    createdOn=datetime.datetime.now(),
                    status=1
                )
                available_timings_queryset1.save()
            available_timings_queryset = AvailableTimings.objects(transactionType=transactionType,status=1).first()

            if request.method == "GET":

                time_list = available_timings_queryset.overridesDatesList
                # print("time_list",time_list)

                for each_override_list in time_list:
                    timings_str_list=[]
                    # print("timingsList",each_override_list)
                    overrideTimingsList = each_override_list.get("timingsList")
                    for each_rec in overrideTimingsList:
                        timings_str_list.append(each_rec.get("fromTime") + " - " +each_rec.get("toTime"))
                    timings_str_list = ', '.join(timings_str_list)
                    overridesDatesList.append({
                        "overrideDate": each_override_list.get("overrideDate"),
                        "formattedTimingsList": timings_str_list,
                        "timingsList": each_override_list.get("timingsList"),

                    })
                # print("overridesDatesListoverridesDatesListoverridesDatesList",overridesDatesList)

                is_enabled = available_timings_queryset.isEnabled
                sundayDict={
                    "day":"Sunday",
                    "is_enabled":available_timings_queryset.sunEnabled,
                    "timingsList":available_timings_queryset.sunAvailableTimingsList
                }
                available_timings_data_list.append(sundayDict)

                mondayDict={
                    "day":"Monday",
                    "is_enabled":available_timings_queryset.monEnabled,
                    "timingsList":available_timings_queryset.monAvailableTimingsList
                }
                available_timings_data_list.append(mondayDict)

                tuesdayDict={
                    "day":"Tuesday",
                    "is_enabled":available_timings_queryset.tueEnabled,
                    "timingsList":available_timings_queryset.tueAvailableTimingsList
                }
                available_timings_data_list.append(tuesdayDict)

                wednesdayDict={
                    "day":"Wednesday",
                    "is_enabled":available_timings_queryset.wedEnabled,
                    "timingsList":available_timings_queryset.wedAvailableTimingsList
                }
                available_timings_data_list.append(wednesdayDict)

                thursdayDict={
                    "day":"Thursday",
                    "is_enabled":available_timings_queryset.thuEnabled,
                    "timingsList":available_timings_queryset.thuAvailableTimingsList
                }
                available_timings_data_list.append(thursdayDict)

                fridayDict={
                    "day":"Friday",
                    "is_enabled":available_timings_queryset.friEnabled,
                    "timingsList":available_timings_queryset.friAvailableTimingsList
                }
                available_timings_data_list.append(fridayDict)

                saturdayDict={
                    "day":"Saturday",
                    "is_enabled":available_timings_queryset.satEnabled,
                    "timingsList":available_timings_queryset.satAvailableTimingsList
                }
                available_timings_data_list.append(saturdayDict)
                
                # print("dataaaaaaaa",available_timings_data_list )
                # print("overridesDatesList",overridesDatesList )

                return render_template(
                            "super_admin_templates/available_timings.html",
                            payinTimingsList=payinTimingsList,
                            redirectval=redirectTo,
                            available_timings_data_list=available_timings_data_list,
                            is_enabled=is_enabled,
                            overridesDatesList=overridesDatesList,transactionType=transactionType
                        )

            elif request.method == "POST":
                action = request.form.get("action", "").strip()
                data = request.form.to_dict()
                latitude = request.form.get("latitude", "")
                longitude = request.form.get("longitude", "")
               
                otp_check_id = request.form.get("otpLogid", "")
                if not otp_check_id:
                    flash("Invalid Request.")
                    data_status['responseStatus']=4
                    return data_status
                    

                otpcheck_queryset = OtpChecks.objects(adminId=adminId, id=str(otp_check_id), status=1).first()
                
                if not otpcheck_queryset:
                    flash("Invalid Request.")
                    data_status['responseStatus']=4
                    return data_status
                # Update OTP status to 2 after verification
                otpcheck_queryset.update(status=2)
                    # return jsonify({"responseStatus": 1, "result": "OTP status successfully updated!"})

                # print("request.form ",request.form)
                transactionType =request.args.get("transactionType","")
                redirectTo ="timingsList"
                is_enabled = request.form.get('is_enabled') == 'True'
                sun_enabled = request.form.get('Sunday_is_enabled')== 'True'
                sun_from_times = request.form.getlist('from_time_Sunday[]')
                sun_to_times = request.form.getlist('to_time_Sunday[]')

                mon_enabled = request.form.get('Monday_is_enabled') == 'True'
                mon_from_times = request.form.getlist('from_time_Monday[]')
                mon_to_times = request.form.getlist('to_time_Monday[]')

                tue_enabled = request.form.get('Tuesday_is_enabled') == 'True'
                tue_from_times = request.form.getlist('from_time_Tuesday[]')
                tue_to_times = request.form.getlist('to_time_Tuesday[]')

                wed_enabled = request.form.get('Wednesday_is_enabled') == 'True'
                wed_from_times = request.form.getlist('from_time_Wednesday[]')
                wed_to_times = request.form.getlist('to_time_Wednesday[]')

                thu_enabled = request.form.get('Thursday_is_enabled') == 'True'
                thu_from_times = request.form.getlist('from_time_Thursday[]')
                thu_to_times = request.form.getlist('to_time_Thursday[]')

                fri_enabled = request.form.get('Friday_is_enabled') == 'True'
                fri_from_times = request.form.getlist('from_time_Friday[]')
                fri_to_times = request.form.getlist('to_time_Friday[]')

                sat_enabled = request.form.get('Saturday_is_enabled') == 'True'
                sat_from_times = request.form.getlist('from_time_Saturday[]')
                sat_to_times = request.form.getlist('to_time_Saturday[]')

                jsonData = request.form.to_dict(flat=True)
                requestData = [jsonData]
                updatedrequestData = [jsonData]
                is_valid, error_list = validate_available_timings(
                    transactionType, is_enabled, sun_enabled, sun_from_times, sun_to_times,
                    mon_enabled, mon_from_times, mon_to_times,
                    tue_enabled, tue_from_times, tue_to_times,
                    wed_enabled, wed_from_times, wed_to_times,
                    thu_enabled, thu_from_times, thu_to_times,
                    fri_enabled, fri_from_times, fri_to_times,
                    sat_enabled, sat_from_times, sat_to_times
                )
                # print("is valid", is_valid)
                # print("errorrrrvalid", error_list)
        
                # print("created new",sun_enabled,is_enabled)
                if is_valid:
                    admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                    if admin_queryset:
                        message=admin_queryset.userName+" "+transactionType+" Available times created successfully!"
                        save_admin_log_table = save_admin_logs_data(adminId,None,None,"available_timings","create",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 
                    available_timings_queryset = AvailableTimings.objects(transactionType=transactionType,status=1).first()

                    if available_timings_queryset:
                        # print("inside updte")
                        # print(f"""
                        # Sunday Enabled: {sun_enabled}, Sunday From Times: {sun_from_times}, Sunday To Times: {sun_to_times}
                        # Monday Enabled: {mon_enabled}, Monday From Times: {mon_from_times}, Monday To Times: {mon_to_times}
                        # Tuesday Enabled: {tue_enabled}, Tuesday From Times: {tue_from_times}, Tuesday To Times: {tue_to_times}
                        # Wednesday Enabled: {wed_enabled}, Wednesday From Times: {wed_from_times}, Wednesday To Times: {wed_to_times}
                        # Thursday Enabled: {thu_enabled}, Thursday From Times: {thu_from_times}, Thursday To Times: {thu_to_times}
                        # Friday Enabled: {fri_enabled}, Friday From Times: {fri_from_times}, Friday To Times: {fri_to_times}
                        # Saturday Enabled: {sat_enabled}, Saturday From Times: {sat_from_times}, Saturday To Times: {sat_to_times}
                        # """,type(sun_enabled))
                        available_timings_queryset.isEnabled = is_enabled
                        available_timings_queryset.sunEnabled = sun_enabled
                        available_timings_queryset.sunAvailableTimingsList = [{"fromTime": ft, "toTime": tt} for ft, tt in zip(sun_from_times, sun_to_times)]
                        available_timings_queryset.monEnabled = mon_enabled
                        available_timings_queryset.monAvailableTimingsList = [{"fromTime": ft, "toTime": tt} for ft, tt in zip(mon_from_times, mon_to_times)]
                        available_timings_queryset.tueEnabled = tue_enabled
                        available_timings_queryset.tueAvailableTimingsList = [{"fromTime": ft, "toTime": tt} for ft, tt in zip(tue_from_times, tue_to_times)]
                        available_timings_queryset.wedEnabled = wed_enabled
                        available_timings_queryset.wedAvailableTimingsList = [{"fromTime": ft, "toTime": tt} for ft, tt in zip(wed_from_times, wed_to_times)]
                        available_timings_queryset.thuEnabled = thu_enabled
                        available_timings_queryset.thuAvailableTimingsList = [{"fromTime": ft, "toTime": tt} for ft, tt in zip(thu_from_times, thu_to_times)]
                        available_timings_queryset.friEnabled = fri_enabled
                        available_timings_queryset.friAvailableTimingsList = [{"fromTime": ft, "toTime": tt} for ft, tt in zip(fri_from_times, fri_to_times)]
                        available_timings_queryset.satEnabled = sat_enabled
                        available_timings_queryset.satAvailableTimingsList = [{"fromTime": ft, "toTime": tt} for ft, tt in zip(sat_from_times, sat_to_times)]
                        available_timings_queryset.status = 1
                        available_timings_queryset.createdOn = datetime.datetime.now()
                        available_timings_queryset.save()
                    flash("Available Timings saved successfully", "success")
                    data_status['responseStatus']=1
                    return data_status
                    # return redirect(url_for("patterns_configuarations.available_timings",redirectval=redirectTo,transactionType=transactionType))
                else:

                    # Flash error messages from the validation result
                    for field, message in error_list.items():
                        flash(message, "danger")
                    
                    data_status["responseStatus"] = 4
                    data_status["result"] = error_list
                    return data_status
        else:
            flash("The staff member does not have permission to view Available timings", "danger")
            return redirect(url_for("admin.dashboard"))

    except Exception as e:
        print("((((((((((((((((available exception))))))))))))))))")
        app.logger.error(traceback.format_exc())
        data_status["result"] = "An error occurred while fetching Available Options!"
        data_status["responseStatus"] = 4
        return data_status

@patterns_configuarations.route("/add_override_date", methods=["POST", "GET"])
@adminid_access_token_required
@csrf_protect
def add_override_date():
    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,"payinAvailableTimePermissions")
        if "add" in permissionsList:
            data_status = {"responseStatus": 0, "result": ""}
            redirectTo = "overrides_dates_list"

            action = request.form.get("action", "").strip()
            data = request.form.to_dict()
            # Step 1: Handle OTP Generation
           
            otp_check_id = request.form.get("otpLogid", "")
            # print("otp_check_id",otp_check_id)
            if not otp_check_id:
                flash("Invalid Request.")
                return redirect(url_for("patterns_configuarations.get_patterns_configuarations_list"))

            otpcheck_queryset = OtpChecks.objects(adminId=adminId, id=str(otp_check_id), status=1).first()

            if not otpcheck_queryset:
                flash("Invalid Request.")
                return redirect(url_for("patterns_configuarations.get_patterns_configuarations_list"))
            # Update OTP status to 2 after verification
            otpcheck_queryset.update(status=2)


            # Fetch form data
            # print("requestsssssssss", request.form)
            transactionType =request.args.get("transactionType","")
            overrideDate = request.form.get('overrideDate')  # Get the override date
            from_times = request.form.getlist('from_time[]')  # List of from times
            to_times = request.form.getlist('to_time[]')  # List of to times

            # print("overrideDate", overrideDate)
            # print("from_times", from_times)
            # print("to_times", to_times)

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

            # Validate input
            if not overrideDate or not from_times or not to_times or not transactionType:
                print("(((((((((((((((((Required fields are missing!)))))))))))))))))")
                flash("Required fields are missing!", "danger")
                return redirect(url_for("patterns_configuarations.available_timings",redirectval=redirectTo,transactionType=transactionType))

            # Build the timings list
            timingsList = [{"fromTime": ft, "toTime": tt} for ft, tt in zip(from_times, to_times)]

            # Fetch the database record
            available_timings_queryset = AvailableTimings.objects(transactionType=transactionType, status=1).first()
            if not available_timings_queryset:
                flash("No available timings found!", "danger")
                return redirect(url_for("patterns_configuarations.available_timings",redirectval=redirectTo,transactionType=transactionType))

            # Check for duplicates in overridesDatesList
            overridesDatesList = available_timings_queryset.overridesDatesList
            for override in overridesDatesList:
                if override["overrideDate"] == overrideDate:  # If the date already exists
                    flash(f"An override already exists for the date: {overrideDate}")
                    return redirect(url_for("patterns_configuarations.available_timings",redirectval=redirectTo,transactionType=transactionType))

            # Add the new override date and timings
            overridesDatesListDict = {
                "overrideDate": overrideDate,
                "timingsList": timingsList
            }
            overridesDatesList.append(overridesDatesListDict)

            # Save the updated list back to the database
            available_timings_queryset.update(overridesDatesList=overridesDatesList)

            admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
            if admin_queryset:
                message=admin_queryset.userName+" "+overrideDate+" override date created successfully!"
                save_admin_log_table = save_admin_logs_data(adminId,None,None,"add_override_date","create",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 

            flash("Override date added successfully!", "success")
            return redirect(url_for("patterns_configuarations.available_timings",redirectval=redirectTo,transactionType=transactionType))
        else:
            flash("The staff member does not have permission to create a Override date.", "danger")
            return redirect(url_for("patterns_configuarations.available_timings"))
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("An error occurred while adding the override date.", "danger")
        return redirect(url_for("patterns_configuarations.available_timings",redirectval=redirectTo,transactionType=transactionType))


@patterns_configuarations.route("/update_override_date", methods=["POST", "GET"])
@adminid_access_token_required
@csrf_protect
def update_override_date():
    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
    redirectTo = "overrides_dates_list"
    # 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()

    try:
        permissionsList = check_permissions(session.get("adminId"),"payinAvailableTimePermissions")
        if "edit" in permissionsList:
            data_status = {"responseStatus": 0, "result": ""}
            transactionType =request.args.get("transactionType","")


            action = request.form.get("action", "").strip()
            data = request.form.to_dict()
            # Step 1: Handle OTP Generation
            
               
            otp_check_id = request.form.get("otpLogid", "")
            print("otp_check_id",otp_check_id)
            if not otp_check_id:
                flash("Invalid Request.")
                return redirect(url_for("patterns_configuarations.available_timings",redirectval=redirectTo,transactionType=transactionType))

            otpcheck_queryset = OtpChecks.objects(adminId=adminId, id=str(otp_check_id), status=1).first()

            if not otpcheck_queryset:
                flash("Invalid Request.")
                return redirect(url_for("patterns_configuarations.available_timings",redirectval=redirectTo,transactionType=transactionType))
            # Update OTP status to 2 after verification
            otpcheck_queryset.update(status=2)


            # Fetch form data
            overrideDate = request.form.get("overrideDate")        # The date to identify the record to update
            from_times = request.form.getlist("from_time[]")       # New 'from' times
            to_times = request.form.getlist("to_time[]")           # New 'to' times

            print("overrideDate", overrideDate)
            print("from_times", from_times)
            print("to_times", to_times)
            print("redirectTo", redirectTo)

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

            # Validate input
            if not overrideDate or not from_times or not to_times:
                flash("Required fields are missing!")
                return redirect(url_for("patterns_configuarations.available_timings",redirectval=redirectTo,transactionType=transactionType))

            # Build the new timings list
            updatedTimingsList = [{"fromTime": ft, "toTime": tt} for ft, tt in zip(from_times, to_times)]

            # Fetch the database record
            available_timings_queryset = AvailableTimings.objects(transactionType=transactionType, status=1).first()
            admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
            existing_record = available_timings_queryset.to_json()
            message=admin_queryset.userName+" "+overrideDate+" Override date updated successfully!"
            requestData=[available_timings_queryset]
            updatedrequestData=[jsonData]
            save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_override_date","update",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 

            if not available_timings_queryset:
                flash("No available timings found!")
                return redirect(url_for("patterns_configuarations.available_timings",redirectval=redirectTo,transactionType=transactionType))

            # Find and update the matching record in overridesDatesList
            overridesDatesList = available_timings_queryset.overridesDatesList
            for override in overridesDatesList:
                if override["overrideDate"] == overrideDate:  # Match the date
                    override["timingsList"] = updatedTimingsList  # Update timings list
                    break
            else:
                flash("No matching override date found!")
                return redirect(url_for("patterns_configuarations.available_timings",redirectval=redirectTo,transactionType=transactionType))

            # Save the updated list back to the database
            available_timings_queryset.update(overridesDatesList=overridesDatesList)
            print("(((((((((((overrrrrrrrrrrrrr)))))))))))")
            flash("Override date updated successfully!")
            return redirect(url_for("patterns_configuarations.available_timings",redirectval=redirectTo,transactionType=transactionType))
        else:
            flash("The staff member does not have permission to update Override date.", "danger")
            return redirect(url_for("patterns_configuarations.available_timings")) 
           
    except Exception as e:
        print("((((((((((((((((update exception))))))))))))))))")
        app.logger.error(traceback.format_exc())
        flash("An error occurred while updating the override date.")
        return redirect(url_for("patterns_configuarations.available_timings",redirectval=redirectTo,transactionType=transactionType))


# @patterns_configuarations.route("/delete_override_date", methods=["GET"])
# def delete_override_date():
#     try:
#         data_status = {"responseStatus": 0, "result": ""}
#         redirectTo = "overrides_dates_list"

#         # Fetch the override date to delete
#         transactionType =request.args.get("transactionType","")
#         overrideDate = request.args.get("overrideDate")
#         print("overrideDate to delete:", overrideDate)

#         # Validate input
#         if not overrideDate:
#             flash("Override date is required!")
#             return redirect(url_for("patterns_configuarations.available_timings",redirectval=redirectTo,transactionType=transactionType))

#         # Fetch the database record
#         available_timings_queryset = AvailableTimings.objects(transactionType=transactionType, status=1).first()
#         if not available_timings_queryset:
#             flash("No available timings found!")
#             return redirect(url_for("patterns_configuarations.available_timings",redirectval=redirectTo,transactionType=transactionType))

#         # Remove the matching record from overridesDatesList
#         overridesDatesList = available_timings_queryset.overridesDatesList
#         updatedOverridesList = [override for override in overridesDatesList if override["overrideDate"] != overrideDate]

#         # If no changes were made (overrideDate not found), return a message
#         if len(overridesDatesList) == len(updatedOverridesList):
#             flash("No matching override date found!")
#             return redirect(url_for("patterns_configuarations.available_timings",redirectval=redirectTo,transactionType=transactionType))

#         # Save the updated list back to the database
#         available_timings_queryset.update(overridesDatesList=updatedOverridesList)

#         flash("Override date deleted successfully!")
#         return redirect(url_for("patterns_configuarations.available_timings",redirectval=redirectTo,transactionType=transactionType))

#     except Exception as e:
#         app.logger.error(f"Error deleting override date: {str(e)}")
#         flash("An error occurred while deleting the override date.")
#         return redirect(url_for("patterns_configuarations.available_timings",redirectval=redirectTo,transactionType=transactionType))


@patterns_configuarations.route("/delete_override_date", methods=["POST"])
@adminid_access_token_required
@csrf_protect
def delete_override_date():
    existing_record=""
    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")
    userAgent=""
    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)

    requestData = [existing_record]
    updatedrequestData = [jsonData]

    try:
        permissionsList = check_permissions(session.get("adminId"),"payinAvailableTimePermissions")
        if "delete" in permissionsList:
            data_status = {"responseStatus": 0, "result": ""}
            redirectTo = "overrides_dates_list"

            transactionType = request.args.get("transactionType", "")
            overrideDate = request.args.get("overrideDate")

            action = request.form.get("action", "").strip()
            data = request.form.to_dict()

            # Step 1: Handle OTP Generation
           
            otp_check_id = request.form.get("otpLogid", "")
            print("otp_check_id",otp_check_id)
            if not otp_check_id:
                flash("Invalid Request.")
                return redirect(url_for("patterns_configuarations.available_timings", redirectval=redirectTo, transactionType=transactionType))

            otpcheck_queryset = OtpChecks.objects(adminId=adminId, id=str(otp_check_id), status=1).first()

            if not otpcheck_queryset:
                flash("Invalid Request.")
                return redirect(url_for("patterns_configuarations.available_timings", redirectval=redirectTo, transactionType=transactionType))
            # Update OTP status to 2 after verification
            otpcheck_queryset.update(status=2)


            # Step 4: Proceed with Deletion **Only after OTP verification**
            if not overrideDate:
                flash("Override date is required!")
                return redirect(url_for("patterns_configuarations.available_timings", redirectval=redirectTo, transactionType=transactionType))

            available_timings_queryset = AvailableTimings.objects(transactionType=transactionType, status=1).first()
            existing_record = available_timings_queryset.to_json()
            if not available_timings_queryset:
                flash("No available timings found!")
                return redirect(url_for("patterns_configuarations.available_timings", redirectval=redirectTo, transactionType=transactionType))

            overridesDatesList = available_timings_queryset.overridesDatesList
            updatedOverridesList = [override for override in overridesDatesList if override["overrideDate"] != overrideDate]

            if len(overridesDatesList) == len(updatedOverridesList):
                flash("No matching override date found!")
                return redirect(url_for("patterns_configuarations.available_timings", redirectval=redirectTo, transactionType=transactionType))

            available_timings_queryset.update(overridesDatesList=updatedOverridesList)
            admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
            message=admin_queryset.userName+" "+overrideDate+" Override date deleted successfully!"
            save_admin_log_table = save_admin_logs_data(adminId,None,None,"delete_override_date","delete",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)

            flash("Override date deleted successfully!","success")
            return redirect(url_for("patterns_configuarations.available_timings", redirectval=redirectTo, transactionType=transactionType))
        else:
            flash("The staff member does not have permission to delete Override date.", "danger")
            return redirect(url_for("patterns_configuarations.available_timings"))
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("An error occurred while deleting the override date.")
        return redirect(url_for("patterns_configuarations.available_timings", redirectval=redirectTo, transactionType=transactionType))


@patterns_configuarations.route("/dynamic_profile_switch",methods=["POST","GET"])
@adminid_access_token_required
def dynamic_profile_switch():
    redirectTo =request.args.get("redirectval","profileSwitch")
    try:
        permissionsList = check_permissions(session.get("adminId"),"dynamicProfileSwitchPermissions")
        if "view" in permissionsList:
            data_status = {"responseStatus": 0, "result":""}

            existingPatternsList=[]

            user_queryset = Patterns.objects(status=1).all()
            for each_user in user_queryset:
                patternDict = {
                    "patternId":str(each_user.id),
                    "patternName":each_user.name
                }
                if patternDict not in existingPatternsList:
                    existingPatternsList.append(patternDict)

            if not session.get("adminId"):
                return redirect("admin_login")
            adminId = session.get("adminId")

            profile_queryset0 = ProfileSwitch.objects(status=1).first()
            profile_switch_data_list=[]
            overridesProfileList = []
            timings_str_list=[]


            # If the record doesn't exist, create a new one
            if not profile_queryset0:
                profile_queryset1 = ProfileSwitch(
                    sunEnabled = False,
                    sunDefaultEnable = False,
                    sunProfileList = [],
                    monEnabled = False,
                    monDefaultEnable = False,
                    monProfileList = [],
                    tueEnabled = False,
                    tueDefaultEnable = False,
                    tueProfileList = [],
                    wedEnabled = False,
                    wedDefaultEnable = False,
                    wedProfileList = [],
                    thuEnabled = False,
                    thuDefaultEnable = False,
                    thuProfileList = [],
                    friEnabled = False,
                    friDefaultEnable = False,
                    friProfileList = [],
                    satEnabled = False,
                    satDefaultEnable = False,
                    satProfileList = [],
                    overridesProfileList = [] ,
                    status = 1,
                    createdOn = datetime.datetime.now(),
                )
                profile_queryset1.save()
            profile_queryset = ProfileSwitch.objects(status=1).first()
            if request.method == "GET":

                overridesProfileListData = profile_queryset.overridesProfileList
                # print("time_list",time_list)

                for each_override_list in overridesProfileListData:
                    override_name_list=[]
                    # print("each_override_list",each_override_list)
                    overrideList = each_override_list.get("overrideList")
                    for each_rec in overrideList:
                        existingProfile =  each_rec.get("defaultProfile")
                        defaultProfile = each_rec.get("applicableProfile")
                        existingProfile_queryset = Patterns.objects(id=existingProfile,status=1).first()
                        defaultProfile_queryset = Patterns.objects(id=str(defaultProfile),status=1).first()
                        if existingProfile_queryset and defaultProfile_queryset:
                            override_name_list.append(existingProfile_queryset.name + " - " +defaultProfile_queryset.name)
                    override_name_list = ', '.join(override_name_list)
                    overridesProfileList.append({
                        "overrideDate": each_override_list.get("overrideDate"),
                        "formattedOverrideList": override_name_list,
                        "overrideList": each_override_list.get("overrideList"),

                    })
                # print("overridesProfileList",overridesProfileList)

                # is_enabled = profile_queryset.isEnabled
                sundayDict={
                    "day":"Sunday",
                    "is_enabled":profile_queryset.sunEnabled,
                    "defaultEnable":profile_queryset.sunDefaultEnable,
                    "profileList":profile_queryset.sunProfileList
                }
                profile_switch_data_list.append(sundayDict)

                mondayDict={
                    "day":"Monday",
                    "is_enabled":profile_queryset.monEnabled,
                    "defaultEnable":profile_queryset.monDefaultEnable,
                    "profileList":profile_queryset.monProfileList
                }
                profile_switch_data_list.append(mondayDict)

                tuesdayDict={
                    "day":"Tuesday",
                    "is_enabled":profile_queryset.tueEnabled,
                    "defaultEnable":profile_queryset.tueDefaultEnable,
                    "profileList":profile_queryset.tueProfileList
                }
                profile_switch_data_list.append(tuesdayDict)

                wednesdayDict={
                    "day":"Wednesday",
                    "is_enabled":profile_queryset.wedEnabled,
                    "defaultEnable":profile_queryset.wedDefaultEnable,
                    "profileList":profile_queryset.wedProfileList
                }
                profile_switch_data_list.append(wednesdayDict)

                thursdayDict={
                    "day":"Thursday",
                    "is_enabled":profile_queryset.thuEnabled,
                    "defaultEnable":profile_queryset.thuDefaultEnable,
                    "profileList":profile_queryset.thuProfileList
                }
                profile_switch_data_list.append(thursdayDict)

                fridayDict={
                    "day":"Friday",
                    "is_enabled":profile_queryset.friEnabled,
                    "defaultEnable":profile_queryset.friDefaultEnable,
                    "profileList":profile_queryset.friProfileList
                }
                profile_switch_data_list.append(fridayDict)

                saturdayDict={
                    "day":"Saturday",
                    "is_enabled":profile_queryset.satEnabled,
                    "defaultEnable":profile_queryset.satDefaultEnable,
                    "profileList":profile_queryset.satProfileList
                }
                profile_switch_data_list.append(saturdayDict)
                
                # print("dataaaaaaaa",profile_switch_data_list )
                # print("overridesProfileList",overridesProfileList )
                print("profileSwitch",redirectTo)

                return render_template(
                            "super_admin_templates/dynamic_profile_switch.html",
                            redirectval=redirectTo,
                            profile_switch_data_list=profile_switch_data_list,
                            existingPatternsList=existingPatternsList,
                            overridesProfileList=overridesProfileList
                        )

            elif request.method == "POST":

                action = request.form.get("action", "").strip()
                data = request.form.to_dict()
                
                
                otp_check_id = request.form.get("otpLogid", "")
                print("otp_check_id",otp_check_id)
                if not otp_check_id:
                    return jsonify({"responseStatus": 0, "result": "Invalid Request."})

                otpcheck_queryset = OtpChecks.objects(adminId=adminId, id=str(otp_check_id), status=1).first()

                if not otpcheck_queryset:
                    return jsonify({"responseStatus": 0, "result": "Invalid Request."})
                    
                # Update OTP status to 2 after verification
                otpcheck_queryset.update(status=2)


                sun_enabled = request.form.get("Sunday_is_enabled") == "True"
                sun_default_enable = request.form.get("Sunday_defaultEnable") == "True"
                sun_default_profiles = request.form.getlist("defaultProfile_Sunday[]")
                sun_applicable_profiles = request.form.getlist("applicableProfile_Sunday[]")

                mon_enabled = request.form.get("Monday_is_enabled") == "True"
                mon_default_enable = request.form.get("Monday_defaultEnable") == "True"
                mon_default_profiles = request.form.getlist("defaultProfile_Monday[]")
                mon_applicable_profiles = request.form.getlist("applicableProfile_Monday[]")

                tue_enabled = request.form.get("Tuesday_is_enabled") == "True"
                tue_default_enable = request.form.get("Tuesday_defaultEnable") == "True"
                tue_default_profiles = request.form.getlist("defaultProfile_Tuesday[]")
                tue_applicable_profiles = request.form.getlist("applicableProfile_Tuesday[]")

                wed_enabled = request.form.get("Wednesday_is_enabled") == "True"
                wed_default_enable = request.form.get("Wednesday_defaultEnable") == "True"
                wed_default_profiles = request.form.getlist("defaultProfile_Wednesday[]")
                wed_applicable_profiles = request.form.getlist("applicableProfile_Wednesday[]")

                thu_enabled = request.form.get("Thursday_is_enabled") == "True"
                thu_default_enable = request.form.get("Thursday_defaultEnable") == "True"
                thu_default_profiles = request.form.getlist("defaultProfile_Thursday[]")
                thu_applicable_profiles = request.form.getlist("applicableProfile_Thursday[]")

                fri_enabled = request.form.get("Friday_is_enabled") == "True"
                fri_default_enable = request.form.get("Friday_defaultEnable") == "True"
                fri_default_profiles = request.form.getlist("defaultProfile_Friday[]")
                fri_applicable_profiles = request.form.getlist("applicableProfile_Friday[]")

                sat_enabled = request.form.get("Saturday_is_enabled") == "True"
                sat_default_enable = request.form.get("Saturday_defaultEnable") == "True"
                sat_default_profiles = request.form.getlist("defaultProfile_Saturday[]")
                sat_applicable_profiles = request.form.getlist("applicableProfile_Saturday[]")

                profile_queryset = ProfileSwitch.objects(status=1).first()

                if profile_queryset:
                    profile_queryset.sunEnabled = sun_enabled
                    profile_queryset.sunDefaultEnable = sun_default_enable
                    profile_queryset.sunProfileList = [
                        {"defaultProfile": dp, "applicableProfile": ap}
                        for dp, ap in zip(sun_default_profiles, sun_applicable_profiles)
                    ] if sun_enabled else []

                    profile_queryset.monEnabled = mon_enabled
                    profile_queryset.monDefaultEnable = mon_default_enable
                    profile_queryset.monProfileList = [
                        {"defaultProfile": dp, "applicableProfile": ap}
                        for dp, ap in zip(mon_default_profiles, mon_applicable_profiles)
                    ] if mon_enabled else []

                    profile_queryset.tueEnabled = tue_enabled
                    profile_queryset.tueDefaultEnable = tue_default_enable
                    profile_queryset.tueProfileList = [
                        {"defaultProfile": dp, "applicableProfile": ap}
                        for dp, ap in zip(tue_default_profiles, tue_applicable_profiles)
                    ] if tue_enabled else []

                    profile_queryset.wedEnabled = wed_enabled
                    profile_queryset.wedDefaultEnable = wed_default_enable
                    profile_queryset.wedProfileList = [
                        {"defaultProfile": dp, "applicableProfile": ap}
                        for dp, ap in zip(wed_default_profiles, wed_applicable_profiles)
                    ] if wed_enabled else []

                    profile_queryset.thuEnabled = thu_enabled
                    profile_queryset.thuDefaultEnable = thu_default_enable
                    profile_queryset.thuProfileList = [
                        {"defaultProfile": dp, "applicableProfile": ap}
                        for dp, ap in zip(thu_default_profiles, thu_applicable_profiles)
                    ] if thu_enabled else []

                    profile_queryset.friEnabled = fri_enabled
                    profile_queryset.friDefaultEnable = fri_default_enable
                    profile_queryset.friProfileList = [
                        {"defaultProfile": dp, "applicableProfile": ap}
                        for dp, ap in zip(fri_default_profiles, fri_applicable_profiles)
                    ] if fri_enabled else []

                    profile_queryset.satEnabled = sat_enabled
                    profile_queryset.satDefaultEnable = sat_default_enable
                    profile_queryset.satProfileList = [
                        {"defaultProfile": dp, "applicableProfile": ap}
                        for dp, ap in zip(sat_default_profiles, sat_applicable_profiles)
                    ] if sat_enabled else []

                    # Save the updated profile
                    profile_queryset.status = 1
                    profile_queryset.createdOn = datetime.datetime.now()
                    profile_queryset.save()

                return redirect(url_for(
                    "patterns_configuarations.dynamic_profile_switch",
                    redirectval=redirectTo
                ))
        else:
            flash("Staff member does not have given view dynamic profile switch permissions!!")
            return redirect(url_for("admin.dashboard")) 

    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("An error occurred while fetching Profile Switch Options!")
        data_status["result"] = "An error occurred while fetching Profile Switch Options!"
        return redirect(url_for("patterns_configuarations.dynamic_profile_switch",redirectval=redirectTo))

@patterns_configuarations.route("/add_override_profile_date", methods=["POST", "GET"])
@adminid_access_token_required
@csrf_protect
def add_override_profile_date():
    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))))))))))))))")

    loginBrowser = request.headers.get("Sec-Ch-Ua")
    userAgent=""
    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()

    try:
        permissionsList = check_permissions(adminId,"dynamicProfileSwitchPermissions")
        if "add" in permissionsList:
            data_status = {"responseStatus": 0, "result": ""}
            redirectTo = "overrideDates"

            action = request.form.get("action", "").strip()
            data = request.form.to_dict()
            # Step 1: Handle OTP Generation
            
            otp_check_id = request.form.get("otpLogid", "")
            print("otp_check_id",otp_check_id)
            if not otp_check_id:
                flash("Invalid Request.")
                return redirect(url_for("patterns_configuarations.dynamic_profile_switch",redirectval=redirectTo))

            otpcheck_queryset = OtpChecks.objects(adminId=adminId, id=str(otp_check_id), status=1).first()

            if not otpcheck_queryset:
                flash("Invalid Request.")
                return redirect(url_for("patterns_configuarations.dynamic_profile_switch",redirectval=redirectTo))
            # Update OTP status to 2 after verification
            otpcheck_queryset.update(status=2)
                

            # Fetch form data
            # print("requestsssssssss", request.form)
            overrideDate = request.form.get('overrideDate')  # Get the override date
            defaultProfile = request.form.getlist('defaultProfile[]')  # List of from times
            applicableProfile = request.form.getlist('applicableProfile[]')  # List of to times

            # print("overrideDate", overrideDate)
            # print("defaultProfile", defaultProfile)
            # print("applicableProfile", applicableProfile)
            jsonData = request.form.to_dict(flat=True)
            requestData = [jsonData]
            updatedrequestData = [jsonData]

            # Validate input
            if not overrideDate or not defaultProfile or not applicableProfile:
                flash("Required fields are missing!")
                return redirect(url_for("patterns_configuarations.dynamic_profile_switch",redirectval=redirectTo))

            # Build the timings list
            overrideList = [{"defaultProfile": ft, "applicableProfile": tt} for ft, tt in zip(defaultProfile, applicableProfile)]

            # Fetch the database record
            profile_switch_queryset = ProfileSwitch.objects( status=1).first()
            if not profile_switch_queryset:
                flash("No Profile Switches found!")
                return redirect(url_for("patterns_configuarations.dynamic_profile_switch",redirectval=redirectTo))

            # Check for duplicates in overridesProfileList
            overridesProfileList = profile_switch_queryset.overridesProfileList
            for override in overridesProfileList:
                if override["overrideDate"] == overrideDate:  # If the date already exists
                    flash(f"An override already exists for the date: {overrideDate}")
                    return redirect(url_for("patterns_configuarations.dynamic_profile_switch",redirectval=redirectTo))

            # Add the new override date and timings
            overridesProfileListDict = {
                "overrideDate": overrideDate,
                "overrideList": overrideList
            }
            overridesProfileList.append(overridesProfileListDict)

            # Save the updated list back to the database
            profile_switch_queryset.update(overridesProfileList=overridesProfileList)

            admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
            if admin_queryset:
                message=admin_queryset.userName+" "+overrideDate+" dynamic profile switch Override date created successfully!"
                save_admin_log_table = save_admin_logs_data(adminId,None,None,"add_override_profile_date","create",actionDate,client_ip,browser,message,requestData,updatedrequestData)

            flash("Override date added successfully!")
            return redirect(url_for("patterns_configuarations.dynamic_profile_switch",redirectval=redirectTo))
        else:
            flash("Staff member does not have given create dynamic profile switch permissions!!")
            return redirect(url_for("patterns_configuarations.dynamic_profile_switch"))
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("An error occurred while adding the override date.")
        return redirect(url_for("patterns_configuarations.dynamic_profile_switch",redirectval=redirectTo))



# @patterns_configuarations.route("/delete_override_profile_date", methods=["POST"])
# def delete_override_profile_date():
#     try:
#         data_status = {"responseStatus": 0, "result": ""}
#         redirectTo = "overrideDates"

#         # Fetch the override date to delete
#         overrideDate = request.args.get("overrideDate")
#         # Validate input
#         if not overrideDate:
#             flash("Override date is required!")
#             return redirect(url_for("patterns_configuarations.dynamic_profile_switch",redirectval=redirectTo))

#         # Fetch the database record
#         profile_switch_queryset = ProfileSwitch.objects(status=1).first()
#         if not profile_switch_queryset:
#             flash("No Override Date found!")
#             return redirect(url_for("patterns_configuarations.dynamic_profile_switch",redirectval=redirectTo))

#         # Remove the matching record from overridesDatesList
#         overridesProfileList = profile_switch_queryset.overridesProfileList
#         updatedOverridesList = [override for override in overridesProfileList if override["overrideDate"] != overrideDate]

#         # If no changes were made (overrideDate not found), return a message
#         if len(overridesProfileList) == len(updatedOverridesList):
#             flash("No matching override date found!")
#             return redirect(url_for("patterns_configuarations.dynamic_profile_switch",redirectval=redirectTo))

#         # Save the updated list back to the database
#         profile_switch_queryset.update(overridesProfileList=updatedOverridesList)

#         flash("Override date deleted successfully!")
#         return redirect(url_for("patterns_configuarations.dynamic_profile_switch",redirectval=redirectTo))

#     except Exception as e:
#         app.logger.error(f"Error deleting override date: {str(e)}")
#         flash("An error occurred while deleting the override date.")
#         return redirect(url_for("patterns_configuarations.dynamic_profile_switch",redirectval=redirectTo))


@patterns_configuarations.route("/delete_override_profile_date", methods=["POST"])
@adminid_access_token_required
@csrf_protect
def delete_override_profile_date():
    try:
        existing_record=""
        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))))))))))))))")
        loginBrowser = request.headers.get("Sec-Ch-Ua")
        userAgent=""
        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)

        requestData = [existing_record]
        updatedrequestData = [jsonData]

        permissionsList = check_permissions(adminId,"dynamicProfileSwitchPermissions")
        if "delete" in permissionsList:
            data_status = {"responseStatus": 0, "result": ""}
            redirectTo = "overrideDates"

            # Step 1: Handle OTP Actions
            action = request.form.get("action", "").strip()
            data = request.form.to_dict()

            otp_check_id = request.form.get("otpLogid", "")
            print("otp_check_id",otp_check_id)
            if not otp_check_id:
                flash("Invalid Request.")
                return redirect(url_for("patterns_configuarations.dynamic_profile_switch", redirectval=redirectTo))

            otpcheck_queryset = OtpChecks.objects(adminId=adminId, id=str(otp_check_id), status=1).first()

            if not otpcheck_queryset:
                flash("Invalid Request.")
                return redirect(url_for("patterns_configuarations.dynamic_profile_switch", redirectval=redirectTo))
            # Update OTP status to 2 after verification
            otpcheck_queryset.update(status=2)

            # Step 2: Proceed with Override Date Deletion (Only if OTP Verified)
            overrideDate = request.args.get("overrideDate")

            if not overrideDate:
                flash("Override date is required!")
                return redirect(url_for("patterns_configuarations.dynamic_profile_switch", redirectval=redirectTo))

            profile_switch_queryset = ProfileSwitch.objects(status=1).first()
            existing_record = profile_switch_queryset.to_json()

            if not profile_switch_queryset:
                flash("No Override Date found!")
                return redirect(url_for("patterns_configuarations.dynamic_profile_switch", redirectval=redirectTo))

            overridesProfileList = profile_switch_queryset.overridesProfileList
            updatedOverridesList = [override for override in overridesProfileList if override["overrideDate"] != overrideDate]

            if len(overridesProfileList) == len(updatedOverridesList):
                flash("No matching override date found!")
                return redirect(url_for("patterns_configuarations.dynamic_profile_switch", redirectval=redirectTo))

            profile_switch_queryset.update(overridesProfileList=updatedOverridesList)
            admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
            message=admin_queryset.userName+" "+overrideDate+" dynamic profile switch Override date deleted successfully!"
            save_admin_log_table = save_admin_logs_data(adminId,None,None,"delete_override_profile_date","delete",actionDate,client_ip,browser,message,requestData,updatedrequestData)

            flash("Override date deleted successfully!")
            return redirect(url_for("patterns_configuarations.dynamic_profile_switch", redirectval=redirectTo))
        else:
            flash("Staff member does not have given delete dynamic profile switch permissions!!")
            return redirect(url_for("patterns_configuarations.dynamic_profile_switch"))
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("An error occurred while deleting the override date.")
        return redirect(url_for("patterns_configuarations.dynamic_profile_switch", redirectval=redirectTo))

@patterns_configuarations.route("/update_override_profile_date", methods=["POST", "GET"])
@adminid_access_token_required
@csrf_protect
def update_override_profile_date():
    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))))))))))))))")  
        loginBrowser = request.headers.get("Sec-Ch-Ua")
        userAgent=""
        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,"dynamicProfileSwitchPermissions")
        if "edit" in permissionsList:
            data_status = {"responseStatus": 0, "result": ""}
            redirectTo = "overrideDates"

            action = request.form.get("action", "").strip()
            data = request.form.to_dict()
            # Step 1: Handle OTP Generation
            

            otp_check_id = request.form.get("otpLogid", "")
            print("otp_check_id",otp_check_id)
            if not otp_check_id:
                flash("Invalid Request.")
                return redirect(url_for("patterns_configuarations.dynamic_profile_switch",redirectval=redirectTo))

            otpcheck_queryset = OtpChecks.objects(adminId=adminId, id=str(otp_check_id), status=1).first()

            if not otpcheck_queryset:
                flash("Invalid Request.")
                return redirect(url_for("patterns_configuarations.dynamic_profile_switch",redirectval=redirectTo))
            # Update OTP status to 2 after verification
            otpcheck_queryset.update(status=2)

            # Fetch form data
            print("requesttttt",request.form)
            overrideDate = request.form.get('overrideDate')  
            defaultProfile = request.form.getlist('defaultProfile[]') 
            applicableProfile = request.form.getlist('applicableProfile[]')

            print("overrideDate", overrideDate)
            print("defaultProfile", defaultProfile)
            print("defaultProfile", defaultProfile)
            print("redirectTo", redirectTo)
            jsonData = request.form.to_dict(flat=True)

            if not overrideDate or not defaultProfile or not applicableProfile:
                flash("Required fields are missing!")
                return redirect(url_for("patterns_configuarations.dynamic_profile_switch",redirectval=redirectTo))

            # Build the new timings list
            updatedOverrideList = [{"defaultProfile": ft, "applicableProfile": tt} for ft, tt in zip(defaultProfile, applicableProfile)]

            profile_switch_queryset = ProfileSwitch.objects( status=1).first()
            admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
            existing_record = profile_switch_queryset.to_json()
            message=admin_queryset.userName+" "+overrideDate+" dynamic profile switch Override date updated successfully!"
            requestData=[existing_record]
            updatedrequestData=[jsonData]
            save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_override_profile_date","update",actionDate,client_ip,browser,message,requestData,updatedrequestData)

            if not profile_switch_queryset:
                flash("No Profile Switches found!")
                return redirect(url_for("patterns_configuarations.dynamic_profile_switch",redirectval=redirectTo))

            # Find and update the matching record in overridesDatesList
            overridesProfileList = profile_switch_queryset.overridesProfileList
            for override in overridesProfileList:
                if override["overrideDate"] == overrideDate:  # Match the date
                    override["overrideList"] = updatedOverrideList  # Update timings list
                    break
            else:
                flash("No matching override date found!")
                return redirect(url_for("patterns_configuarations.dynamic_profile_switch",redirectval=redirectTo))

            # Save the updated list back to the database
            profile_switch_queryset.update(overridesProfileList=overridesProfileList)

            flash("Override date updated successfully!")
            return redirect(url_for("patterns_configuarations.dynamic_profile_switch",redirectval=redirectTo))
        else:
            flash("Staff member does not have given update dynamic profile switch permissions!!")
            return redirect(url_for("patterns_configuarations.dynamic_profile_switch"))
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("An error occurred while updating the override date.")
        return redirect(url_for("patterns_configuarations.dynamic_profile_switch",redirectval=redirectTo))


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

    # Initialize lists
    commissionsList = []
    patternsList = []
    paymentsModeList = []
    subPaymentsModeList = []
    error = None
    success_message = None
    editable = False
    update = False
    setup_charge_commission={}
    setup_charge_commission_dict={}
    setup_charge_commission_list=[]
    price_ranges = []
    showData=False
    instantSettlement=False
    paymentModeName = ""
    patternName = ""

    adminId = session.get("adminId")
    permissionsList = check_permissions(session.get("adminId"), "chargeCommissionsPermissions")

    

    if "view" in permissionsList:
        patternId = request.args.get("patternId")
        paymentModeId = request.args.get("paymentModeId")
        subPaymentModeId = request.args.get("subPaymentModeId")
        instantSettlement = request.args.get("instantSettlement")
        form = MerchantSetupChargeSearchForm(request.args)
        try:
            action = request.form.get("action", "").strip()
            data = request.form.to_dict()
            # Step 1: Handle OTP Generation
            
            # otp_check_id = request.form.get("otpLogid", "")
            # print("otp_check_id",otp_check_id)
            # if not otp_check_id:
            #     flash("Invalid Request.")
            #     return render_template("super_admin_templates/merchant_setup_charge_commissions_table_list.html")

            # otpcheck_queryset = OtpChecks.objects(adminId=adminId, id=str(otp_check_id), status=1).first()

            # if not otpcheck_queryset:
            #     flash("Invalid Request.")
            #     return render_template("super_admin_templates/merchant_setup_charge_commissions_table_list.html")
            # # Update OTP status to 2 after verification
            # otpcheck_queryset.update(status=2)


            redirectTo = request.args.get("redirectTo", "Commission")
            search_action = request.args.get("action")

            ######################## Common Lists ###########################

            patterns_queryset = Patterns.objects(status__in=[0, 1]).order_by("-id").all()
            for each_pattern in patterns_queryset:
                patternsList.append(fetching_pattern_details(each_pattern))

            payments_mod_queryset = PaymentMode.objects(status__in=[0, 1]).order_by("-id").all()
            for each_payment_mode in payments_mod_queryset:
                paymentsModeList.append(fetching_payment_mode_details(each_payment_mode))

         
            # patternId=None
            # paymentModeId=None
            # instantSettlement=None
            if request.method == "GET" and request.args.get("action") == "search":
                if form.validate():
                    editable = True
                    update = True

                    # print(patternId,"(((((((((patternId)))))))))")
                    # print(paymentModeId,"(((((((((paymentModeId)))))))))")
                    # print(subPaymentModeId,"(((((((((subPaymentModeId)))))))))")
                    print(instantSettlement,"(((((((((instantSettlement)))))))))")

                    # Search for matching records
                    
                    payments_mod_queryset1 = PaymentMode.objects(id=paymentModeId,status__in=[0, 1]).first()

                    patterns_queryset = Patterns.objects(id=patternId,status__in=[0, 1]).first()

                    paymentModeName = payments_mod_queryset1.paymentMode
                    patternName = patterns_queryset.name

                    print(paymentModeName,"(((((((((paymentModeName)))))))))")
                    print(patternName,"(((((((((patternName)))))))))")
                    print(type(instantSettlement),"(((((((((instantSettlement)))))))))")
                    print(instantSettlement,"(((((((((instantSettlement)))))))))")

                    if instantSettlement == "True":
                        instantSettlement = True
                    else:
                        instantSettlement = False
                    print(instantSettlement,"instantSettlement")
                    print(type(instantSettlement),"instantSettlement")
                    sub_payments_mod_queryset = SubPaymentModes.objects(paymentModeId=paymentModeId,status__in=[0, 1]).order_by("priority").all()
                    for each_sub_payment_mode in sub_payments_mod_queryset:
                        setup_charge_commission_queryset = SetupChargeCommissions.objects(paymentModeIdsList__in=[paymentModeId],subPaymentModeIdsList__in=[str(each_sub_payment_mode.id)],patternIdsList__in=[patternId],
                        instantSettlement=instantSettlement,
                        status=1).first()

                        if setup_charge_commission_queryset:
                            finalPrice=0
                            price_ranges=[]
                            if setup_charge_commission_queryset.priceType == 'RANGE':
                                price_ranges = setup_charge_commission_queryset.priceRangeList

                            finalPrice=float(setup_charge_commission_queryset.chargeValue)
                            if setup_charge_commission_queryset.gstInclude=="No":
                                finalPrice=float(finalPrice)+float(setup_charge_commission_queryset.chargeValue)*float(setup_charge_commission_queryset.gstValue)/100
                            if setup_charge_commission_queryset.tdsInclude=="No":
                                finalPrice=float(finalPrice)+float(setup_charge_commission_queryset.chargeValue)*float(setup_charge_commission_queryset.tdsValue)/100

                            setup_charge_commission_dict= {
                                "id":str(each_sub_payment_mode.id),
                                "subPaymentModeType": each_sub_payment_mode.subPaymentModeType,  # Use the subPaymentModeType
                                "subPaymentModeId": str(each_sub_payment_mode.id),  # Keep the ID for reference
                                "priceType": setup_charge_commission_queryset.priceType,
                                "chargeType": setup_charge_commission_queryset.chargeType,
                                "chargeValue": setup_charge_commission_queryset.chargeValue,
                                "gstInclude": setup_charge_commission_queryset.gstInclude,
                                "gstValue": setup_charge_commission_queryset.gstValue,
                                "tdsInclude": setup_charge_commission_queryset.tdsInclude,
                                "tdsValue": setup_charge_commission_queryset.tdsValue,
                                "finalPrice": round(finalPrice,2),
                                "price_ranges": price_ranges
                            }
                        else:
                            setup_charge_commission_dict= {
                                "id":str(each_sub_payment_mode.id),
                                "subPaymentModeType": str(each_sub_payment_mode.subPaymentModeType),
                                "subPaymentModeId": str(each_sub_payment_mode.id),
                                "priceType": "",
                                "chargeType": "",
                                "chargeValue": 0,
                                "gstInclude": "",
                                "gstValue": 0,
                                "tdsInclude": "",
                                "tdsValue": 0,
                                "finalPrice": 0,
                                "price_ranges": []
                            }

                        # print("_____dict value",setup_charge_commission_dict)

                        setup_charge_commission_list.append(setup_charge_commission_dict)
                    if len(setup_charge_commission_list) > 0:
                        showData=True

                    print(instantSettlement,"(((((((((((((((((instantSettlement in searching API)))))))))))))))))")
                print(form.errors,"((((((form errors ))))))")

                return render_template(
                    "super_admin_templates/merchant_setup_charge_commissions_table_list.html",
                    patternId=patternId,
                    instantSettlement=instantSettlement,
                    patternsList=patternsList,
                    paymentModeId=paymentModeId,
                    paymentsModeList=paymentsModeList,
                    setup_charge_commission=setup_charge_commission,
                    subPaymentsModeList=subPaymentsModeList,
                    setup_charge_commission_list=setup_charge_commission_list,
                    # priceRangeList=price_ranges,
                    editable=editable,
                    paymentModeName = paymentModeName,
                    patternName = patternName,
                    showData=showData,
                    update= update,
                    form=form
                )

            return render_template("super_admin_templates/merchant_setup_charge_commissions_table_list.html",
                instantSettlement=instantSettlement,
                commissionsList=commissionsList,
                subPaymentsModeList=subPaymentsModeList,
                setup_charge_commission=setup_charge_commission,
                patternsList=patternsList,
                paymentsModeList=paymentsModeList,
                redirectval=redirectTo,
                error=error,
                editable=editable,
                paymentModeName = paymentModeName,
                patternName = patternName,
                showData=showData,
                success_message=success_message,
                form=form
            )

        except Exception as e:
            app.logger.error(traceback.format_exc())
            error = "Unable to fetch setup charge commission details!!"
            flash(error, "error")
            return render_template("super_admin_templates/merchant_setup_charge_commissions_table_list.html",commissionsList=commissionsList,
                instantSettlement=instantSettlement,
                subPaymentsModeList=subPaymentsModeList,
                setup_charge_commission=setup_charge_commission,
                patternsList=patternsList,
                paymentsModeList=paymentsModeList,
                redirectval=redirectTo,
                error=error,
                showData=showData,
                paymentModeName = paymentModeName,
                patternName = patternName,
                editable=editable,
                success_message=success_message,
                form=form
                )
    else:
        flash("The staff member does not have permission to view Merchant setup charge commission", "danger")
        return redirect(url_for("admin.dashboard"))

def validate_api_setup_charges_table(
    gstIncludeList,
    gstValueList,
    tdsIncludeList,
    tdsValueList,
    chargeTypeList,
    chargeValueList
):
    row_count = len(gstIncludeList)
    errors = {}

    # Check all list lengths
    for lst in [gstIncludeList, gstValueList, tdsIncludeList, tdsValueList, chargeTypeList, chargeValueList]:
        if len(lst) != row_count:
            return False, {"form": "All lists must be the same length."}

    for i in range(row_count):
        row = i + 1
        charge_type = chargeTypeList[i].strip()
        gst_include = gstIncludeList[i].strip()
        tds_include = tdsIncludeList[i].strip()

        if charge_type not in ["FLAT", "PERCENTAGE"]:
            errors[f"chargeType{row}"] = f" chargeType must be 'FLAT' or 'PERCENTAGE'"
            

        if gst_include not in ["Yes", "No"]:
            errors[f"gstInclude{row}"] = f" gstInclude must be 'Yes' or 'No'"
            

        if tds_include not in ["Yes", "No"]:
            errors[f"tdsInclude{row}"] = f" tdsInclude must be 'Yes' or 'No'"
            

        for label, value in [
            ("chargeValue", chargeValueList[i]),
            ("gstValue", gstValueList[i]),
            ("tdsValue", tdsValueList[i])
        ]:
            try:
                float(value)
            except ValueError:
                errors[f"{label}{row}"] = f"{label} must be a number"
                

    if errors:
        return False, errors

    return True, {}


def validate_api_setup_charges_list(
    startAmountListField,
    endAmountListField,
    chargeTypeListField,
    chargeValueListField,
):
    row_count = len(startAmountListField)
    errors = {}
    # Check all list lengths
    for lst in [startAmountListField, endAmountListField, chargeTypeListField, chargeValueListField]:
        if len(lst) != row_count:
            return False, {"form": "All lists must be the same length."}

    for i in range(row_count-1):
        row = i + 1
        start_amount = startAmountListField[i+1].strip()
        end_amount = endAmountListField[i].strip()
        end_amount1 = endAmountListField[i+1].strip()
        charge_type = chargeTypeListField[i].strip()
        charge_value = chargeValueListField[i].strip()

        if start_amount:
            try:
                start_amount = float(start_amount)
            except:
                errors[f"startAmount{row+1}"] = f"Start amount must be float"
        else:
            errors[f"startAmount{row+1}"] = f"Start amount is required"

        if end_amount:
            try:
                end_amount = float(end_amount)
            except:
                errors[f"endAmount{row}"] = f"End amount must be float"
        else:
            errors[f"endAmount{row}"] = f"End amount is required"

        if end_amount1:
            try:
                end_amount1 = float(end_amount1)
            except:
                errors[f"endAmount{row+1}"] = f"End amount must be float"
        else:
            errors[f"endAmount{row+1}"] = f"End amount is required"

        if not charge_type:
            errors[f"chargeTypeList{row}"] = f"Charge Type is required"
        
        if charge_type not in ["FLAT", "PERCENTAGE"]:
            errors[f"chargeType{row}"] = f" Charge Type must be 'FLAT' or 'PERCENTAGE'"
        
        if not charge_value:
            errors[f"chargeValueList{row}"] = f"Charge Value is required"
        
        if errors:
            continue
        
        # if start_amount and end_amount:
        if start_amount - end_amount > 0.10:
            errors[f"startAmount{row+1}"] = f"Start amount must not differ from previous end amount by more than 0.1."

        if end_amount1 <= start_amount:
            errors[f"endAmount{row+1}"] = f"End amount must be greater than Start Amount"
            

    if errors:
        return False, errors

    return True, {}




@patterns_configuarations.route("/merchant_upsert_setup_charge_commission_table", methods=["POST"])
@adminid_access_token_required
@csrf_protect
def merchant_upsert_setup_charge_commission_table():
    data_status={"responseStatus": 0, "result": 0}
    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()
    print(request.form,"request.form")
    try:
        patternId = request.form.get("patternId", "")
        paymentModeId = request.form.get("paymentModeId", "")
        instantSettlementType = request.form.get("instantSettlement")
        subPaymentModeIdList = request.form.getlist("subPaymentModeId[]")
        priceType = request.form.get("priceType", "FIXED")
        gstIncludeList = request.form.getlist("gstInclude[]")
        gstValueList = request.form.getlist("gstValue[]")
        tdsIncludeList = request.form.getlist("tdsInclude[]")
        tdsValueList = request.form.getlist("tdsValue[]")
        chargeTypeList = request.form.getlist("chargeType[]")
        chargeValueList = request.form.getlist("chargeValue[]")

        is_valid, error_list = validate_api_setup_charges_table(
            gstIncludeList=gstIncludeList,
            gstValueList=gstValueList,
            tdsIncludeList=tdsIncludeList,
            tdsValueList=tdsValueList,
            chargeTypeList=chargeTypeList,            
            chargeValueList=chargeValueList
            )

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

            price_range_list = []
            commissionsList = []
            priceDict={}
            for i in range(len(subPaymentModeIdList)):
                commissionsDict = {
                    "patternId": patternId,
                    "paymentModeId": paymentModeId,
                    "subPaymentModeId": subPaymentModeIdList[i],
                    # "priceType": priceTypeList[i],
                    "gstInclude": gstIncludeList[i],
                    "gstValue": float(gstValueList[i]) if gstValueList[i] else 0,
                    "tdsInclude": tdsIncludeList[i],
                    "tdsValue": float(tdsValueList[i]) if tdsValueList[i] else 0,
                    "chargeType": chargeTypeList[i],
                    "chargeValue": float(chargeValueList[i]) if chargeValueList[i] else 0,
                }
                commissionsList.append(priceDict) 
                print("commissionsList",commissionsList)
                gstInclude = gstIncludeList[i]
                gstValue = float(gstValueList[i]) if gstValueList[i] else 0
                tdsInclude = tdsIncludeList[i]
                tdsValue = float(tdsValueList[i]) if tdsValueList[i] else 0
                chargeType = chargeTypeList[i]
                chargeValue = float(chargeValueList[i]) if chargeValueList[i] else 0
                subPaymentModeId= subPaymentModeIdList[i]
                print(patternId,"patternId")
                print(paymentModeId,"paymentModeId")
                print(subPaymentModeId,"subPaymentModeId")
                print(priceType,"priceType")
                print(instantSettlementType,"(((((((((((((((((instantSettlement For merchant setup update API)))))))))))))))))")

                if instantSettlementType == "True":
                    instantSettlement = True
                else:
                    instantSettlement = False

                existing_record = SetupChargeCommissions.objects(paymentModeIdsList__in=[paymentModeId],
                    subPaymentModeIdsList__in=[subPaymentModeId],patternIdsList__in=[patternId],instantSettlement=instantSettlement,status=1).first()
                if existing_record:
                    existing_record.update(priceType=priceType,chargeType=chargeType,chargeValue=float(chargeValue),priceRangeList=price_range_list,gstInclude=gstInclude,gstValue=float(gstValue),tdsInclude=tdsInclude,tdsValue=float(tdsValue))
                    # flash("Record updated successfully!", "success")
                else:
                    try:
                        admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                        if admin_queryset:
                            message=admin_queryset.userName+" Merchant Setup charge commission Updated successfully!"
                            save_admin_log_table = save_admin_logs_data(adminId,None,None,"merchant_upsert_setup_charge_commission_table","create",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 
                            print("(((((((((((((save_admin_log_table)))))))))))))",save_admin_log_table)
                        # print("is new record++++++++++++++++++++")
                        print(type(instantSettlement),"(((((((((SAVING instantSettlement In update API TYPE)))))))))")
                        print(instantSettlement,"(((((((((SAVING instantSettlement In update API)))))))))")
                        new_record = SetupChargeCommissions(
                            adminId=session.get("adminId"),
                            patternIdsList=[ObjectId(patternId)],
                            paymentModeIdsList=[ObjectId(paymentModeId)],
                            subPaymentModeIdsList=[ObjectId(subPaymentModeId)],
                            priceType=priceType,
                            gstInclude=gstInclude,
                            gstValue=float(gstValue),
                            tdsInclude=tdsInclude,
                            tdsValue=float(tdsValue),
                            chargeType=chargeType,
                            chargeValue=float(chargeValue),
                            priceRangeList=price_range_list,
                            instantSettlement=instantSettlement,
                            createdOn=datetime.datetime.now(),
                            status=1,
                        )
                        new_record.save()
                    except Exception as e:
                        app.logger.error(traceback.format_exc())
                        flash("Unable to save ticket category!!")
                        data_status["responseStatus"]=4
                        return data_status
            flash("Setup charge commission Details Updated successfully!", "success")
            data_status["responseStatus"]=1
            return data_status
        else:
            print("form errors",error_list)
            data_status["responseStatus"]=0
            data_status["result"]=error_list
            return data_status
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash(f"Error in upserting record: ")
        data_status["responseStatus"]=4
        return data_status

class ApiSetupChargeSearchForm(FlaskForm):
    paymentModeId = SelectField('', choices=[],validate_choice=False,validators=[DataRequired(message="Payment Mode is required.")])
    transactionAPIId = SelectField('', choices=[],validate_choice=False,validators=[DataRequired(message="TransactionApi is required.")])
    holidayPrice = SelectField('', choices=[ ("","Select"),("True","True"),("False","False")],validators=[DataRequired(message="HolidayPrice is required.")])
    print("ApiSetupChargeSearchForm")   
    def validate_patternId(self, field):
        if field.data:
            if not ObjectId.is_valid(field.data):
                raise ValidationError("Invalid Pattern Id.")
            transaction_api_queryset = TransactionAPI.objects(id=field.data,status__in=[0,1]).first()
            if not transaction_api_queryset:
                raise ValidationError("Please select a valid Transaction Api Id.")
            
    def validate_paymentModeId(self, field):
        if field.data:
            if not ObjectId.is_valid(field.data): 
                raise ValidationError("Invalid Payment Id.")
            payment_mode_queryset = PaymentMode.objects(id=field.data,status__nin=[2]).first()
            if not payment_mode_queryset:
                raise ValidationError("Please select a Valid Payment Id")
            
    class Meta:
        csrf = False

@patterns_configuarations.route("/get_api_setup_charge_commissions_table_list", methods=["POST", "GET"])
@adminid_access_token_required
def get_api_setup_charge_commissions_table_list():
    if not session.get("adminId"):
        return redirect("admin_login")
    # Initialize lists
    commissionsList = []
    transactionAPIsList = []
    paymentsModeList = []
    subPaymentsModeList = []
    error = None
    success_message = None
    editable = False
    update = False
    setup_charge_commission={}
    setup_charge_commission_dict={}
    setup_charge_commission_list=[]
    price_ranges = []
    transactionapiName=""
    showData=False
    paymentModeName = ""
    txnName = ""

    adminId = session.get("adminId")
    redirectTo = request.args.get("redirectTo", "Commission")
    permissionsList = check_permissions(session.get("adminId"), "apiSetupchargeCommissionsPermissions")
    if "view" in permissionsList:
        paymentModeId = request.args.get("paymentModeId")
        subPaymentModeId = request.args.get("subPaymentModeId")
        transactionAPIId = request.args.get("transactionAPIId")
        holidayPrice = request.args.get("holidayPrice")
        form = ApiSetupChargeSearchForm(request.args)
        try:
            action = request.form.get("action", "").strip()
            data = request.form.to_dict()
            # Step 1: Handle OTP Generation
           
            # otp_check_id = request.form.get("otpLogid", "")
            # print("otp_check_id",otp_check_id)
            # if not otp_check_id:
            #     flash("Invalid Request.")
            #     return render_template("super_admin_templates/api_setup_charge_commissions_table_list.html")

            # otpcheck_queryset = OtpChecks.objects(adminId=adminId, id=str(otp_check_id), status=1).first()

            # if not otpcheck_queryset:
            #     flash("Invalid Request.")
            #     return render_template("super_admin_templates/api_setup_charge_commissions_table_list.html")
            # # Update OTP status to 2 after verification
            # otpcheck_queryset.update(status=2)


            
            search_action = request.args.get("action")

            ######################## Common Lists ###########################
            transaction_API_queryset = TransactionAPI.objects(status__in=[0, 1]).order_by('-id').all()
            for each_transaction_api in transaction_API_queryset:
                service_grouping_dict = {
                    "id": str(each_transaction_api.id),
                    "apiName": each_transaction_api.apiName
                }
                transactionAPIsList.append(service_grouping_dict)


            payments_mod_queryset = PaymentMode.objects(status__in=[0, 1]).order_by("-id").all()
            for each_payment_mode in payments_mod_queryset:
                paymentsModeList.append(fetching_payment_mode_details(each_payment_mode))

         
            
            if request.method == "GET" and request.args.get("action") == "search":
                if form.validate():
                    
                    editable = True
                    update = True

                    payments_mod_queryset1 = PaymentMode.objects(id=paymentModeId,status__in=[0, 1]).first()

                    txn_queryset = TransactionAPI.objects(id=transactionAPIId,status__in=[0, 1]).first()

                    paymentModeName = payments_mod_queryset1.paymentMode
                    txnName = txn_queryset.apiName

                    print(paymentModeName,"(((((((((paymentModeName)))))))))")
                    print(txnName,"(((((((((txnName)))))))))")
                    print(holidayPrice,"(((((((((holidayPrice)))))))))")

                    if holidayPrice == "True":
                        holidayPrice=True
                    else:
                        holidayPrice=False
                    
                    # print(paymentModeId,"(((((((((paymentModeId)))))))))")
                    # print(subPaymentModeId,"(((((((((subPaymentModeId)))))))))")
                    # print(transactionAPIId,"(((((((((transactionAPIId)))))))))")

                    # Search for matching records
                    
                    transaction_queryset = TransactionAPI.objects(id=str(transactionAPIId)).first()
                    if transaction_queryset:
                        transactionapiName=transaction_queryset.apiName

                    sub_payments_mod_queryset = SubPaymentModes.objects(paymentModeId=paymentModeId,status__in=[0, 1]).order_by("priority").all()
                    for each_sub_payment_mode in sub_payments_mod_queryset:
                        setup_charge_commission_queryset = ApiSetupChargeCommissions.objects(paymentModeIdsList__in=[paymentModeId],subPaymentModeIdsList__in=[str(each_sub_payment_mode.id)],
                        transactionAPIIdsList__in=[transactionAPIId],
                        holidayPrice=holidayPrice,
                        status=1).first()
                        if setup_charge_commission_queryset:
                            finalPrice=0
                            price_ranges=[]
                            if setup_charge_commission_queryset.priceType == 'RANGE':
                                price_ranges = setup_charge_commission_queryset.priceRangeList

                            finalPrice=float(setup_charge_commission_queryset.chargeValue)
                            if setup_charge_commission_queryset.gstInclude=="No":
                                finalPrice=float(finalPrice)+float(setup_charge_commission_queryset.chargeValue)*float(setup_charge_commission_queryset.gstValue)/100
                            if setup_charge_commission_queryset.tdsInclude=="No":
                                finalPrice=float(finalPrice)+float(setup_charge_commission_queryset.chargeValue)*float(setup_charge_commission_queryset.tdsValue)/100

                            setup_charge_commission_dict= {
                                "id":str(each_sub_payment_mode.id),
                                "subPaymentModeType": each_sub_payment_mode.subPaymentModeType,  # Use the subPaymentModeType
                                "subPaymentModeId": str(each_sub_payment_mode.id),  # Keep the ID for reference
                                "priceType": setup_charge_commission_queryset.priceType,
                                "chargeType": setup_charge_commission_queryset.chargeType,
                                "chargeValue": setup_charge_commission_queryset.chargeValue,
                                "gstInclude": setup_charge_commission_queryset.gstInclude,
                                "gstValue": setup_charge_commission_queryset.gstValue,
                                "tdsInclude": setup_charge_commission_queryset.tdsInclude,
                                "tdsValue": setup_charge_commission_queryset.tdsValue,
                                "finalPrice": round(finalPrice,2),
                                "price_ranges": price_ranges
                            }
                        else:
                            setup_charge_commission_dict= {
                                "id":str(each_sub_payment_mode.id),
                                "subPaymentModeType": str(each_sub_payment_mode.subPaymentModeType),
                                "subPaymentModeId": str(each_sub_payment_mode.id),
                                "priceType": "",
                                "chargeType": "",
                                "chargeValue": 0,
                                "gstInclude": "",
                                "gstValue": 0,
                                "tdsInclude": "",
                                "tdsValue": 0,
                                "finalPrice": 0,
                                "price_ranges": []
                            }

                        # print("_____dict value",setup_charge_commission_dict)

                        setup_charge_commission_list.append(setup_charge_commission_dict)
                    if len(setup_charge_commission_list) > 0:
                        showData=True
                    return render_template(
                        "super_admin_templates/api_setup_charge_commissions_table_list.html",
                        paymentModeId=paymentModeId,
                        paymentsModeList=paymentsModeList,
                        transactionAPIId=transactionAPIId,
                        transactionapiName=transactionapiName,
                        transactionAPIsList=transactionAPIsList,
                        setup_charge_commission=setup_charge_commission,
                        subPaymentsModeList=subPaymentsModeList,
                        setup_charge_commission_list=setup_charge_commission_list,
                        holidayPrice=holidayPrice,
                        # priceRangeList=price_ranges,
                        editable=editable,
                        showData=showData,
                        paymentModeName=paymentModeName,
                        txnName=txnName,
                        update= update,
                        form=form
                    )
                print(form.errors,"((((((form errors ))))))")

            return render_template("super_admin_templates/api_setup_charge_commissions_table_list.html",
                commissionsList=commissionsList,
                subPaymentsModeList=subPaymentsModeList,
                setup_charge_commission=setup_charge_commission,
                paymentsModeList=paymentsModeList,
                transactionapiName=transactionapiName,
                transactionAPIsList=transactionAPIsList,
                redirectval=redirectTo,
                error=error,
                editable=editable,
                showData=showData,
                paymentModeName=paymentModeName,
                txnName=txnName,
                success_message=success_message,
                paymentModeId = paymentModeId,
                transactionAPIId = transactionAPIId,
                holidayPrice=holidayPrice,
                form=form
            )

        except Exception as e:
            app.logger.error(traceback.format_exc())
            error = "Unable to fetch setup charge commission details!!"
            flash(error, "error")
            return render_template("super_admin_templates/api_setup_charge_commissions_table_list.html",commissionsList=commissionsList,
                subPaymentsModeList=subPaymentsModeList,
                setup_charge_commission=setup_charge_commission,
                paymentsModeList=paymentsModeList,
                transactionAPIsList=transactionAPIsList,
                transactionapiName=transactionapiName,
                redirectval=redirectTo,
                error=error,
                editable=editable,
                paymentModeName=paymentModeName,
                txnName=txnName,
                showData=showData,
                success_message=success_message,
                form=form
                )
    else:
        flash("The staff member does not have permission to view Api setup charge commission table list.", "danger")
        return redirect(url_for("admin.dashboard"))


@patterns_configuarations.route("/api_upsert_setup_charge_commission_table", methods=["POST"])
@adminid_access_token_required
@csrf_protect
def api_upsert_setup_charge_commission_table():
    data_status={"responseStatus": 0, "result": 0}
    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()

    try:
        print(request.form,"request.form")
        paymentModeId = request.form.get("paymentModeId", "")
        subPaymentModeIdList = request.form.getlist("subPaymentModeId[]")
        transactionAPIId = request.form.get("transactionAPIId", "")
        priceType = request.form.get("priceType", "FIXED")
        gstIncludeList = request.form.getlist("gstInclude[]")
        gstValueList = request.form.getlist("gstValue[]")
        tdsIncludeList = request.form.getlist("tdsInclude[]")
        tdsValueList = request.form.getlist("tdsValue[]")
        chargeTypeList = request.form.getlist("chargeType[]")
        chargeValueList = request.form.getlist("chargeValue[]")
        holidayPrice = request.form.get("holidayPrice",False)
        price_range_list = []
        priceDict={}

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

        is_valid, error_list = validate_api_setup_charges_table(
            gstIncludeList=gstIncludeList,
            gstValueList=gstValueList,
            tdsIncludeList=tdsIncludeList,
            tdsValueList=tdsValueList,
            chargeTypeList=chargeTypeList,            
            chargeValueList=chargeValueList
            )

        if is_valid:

            print("(((((holidayPrice)))))",holidayPrice)
            print("(((((holidayPrice)))))",type(holidayPrice))
            if holidayPrice == "True":
                holidayPrice=True
            else:
                holidayPrice=False
            print("(((((holidayPrice after)))))",holidayPrice)
            for i in range(len(subPaymentModeIdList)):

                gstInclude = gstIncludeList[i]
                gstValue = float(gstValueList[i]) if gstValueList[i] else 0
                tdsInclude = tdsIncludeList[i]
                tdsValue = float(tdsValueList[i]) if tdsValueList[i] else 0
                chargeType = chargeTypeList[i]
                chargeValue = float(""+chargeValueList[i]) if chargeValueList[i] else 0
                subPaymentModeId= subPaymentModeIdList[i]
                # print(paymentModeId,"paymentModeId")
                # print(subPaymentModeId,"subPaymentModeId")
                # print(priceType,"priceType")

                # if gstValue and not is_valid_txn_limit(gstValue):
                #     flash("Please enter a valid Gst Value")
                #     return redirect(url_for("patterns_configuarations.get_api_setup_charge_commissions_table_list"))

                # if tdsValue and not is_valid_txn_limit(tdsValue):
                #     flash("Please enter a valid Tds Value")
                #     return redirect(url_for("patterns_configuarations.get_api_setup_charge_commissions_table_list"))

                # if chargeValue and not is_valid_txn_limit(chargeValue):
                #     flash("Please enter a valid Charge Value")
                #     return redirect(url_for("patterns_configuarations.get_api_setup_charge_commissions_table_list"))
                
                existing_record = ApiSetupChargeCommissions.objects(paymentModeIdsList__in=[paymentModeId],
                    subPaymentModeIdsList__in=[subPaymentModeId],transactionAPIIdsList__in=[transactionAPIId],holidayPrice=holidayPrice,status=1).first()
                if existing_record:
                    existing_record.update(priceType=priceType,chargeType=chargeType,chargeValue=float(chargeValue),priceRangeList=price_range_list,gstInclude=gstInclude,gstValue=float(gstValue),tdsInclude=tdsInclude,tdsValue=float(tdsValue))
                    # flash("updated successfully!", "success")
                else:
                    admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                    if admin_queryset:
                        message=admin_queryset.userName+" Api Setup charge commission table Details Updated successfully!"
                        save_admin_log_table = save_admin_logs_data(adminId,None,None,"api_upsert_setup_charge_commission_table","create",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 
                    # print("is new record++++++++++++++++++++")
                    new_record = ApiSetupChargeCommissions(
                        adminId=session.get("adminId"),
                        paymentModeIdsList=[ObjectId(paymentModeId)],
                        transactionAPIIdsList=[ObjectId(transactionAPIId)],
                        subPaymentModeIdsList=[ObjectId(subPaymentModeId)],
                        priceType=priceType,
                        gstInclude=gstInclude,
                        gstValue=float(gstValue),
                        tdsInclude=tdsInclude,
                        tdsValue=float(tdsValue),
                        chargeType=chargeType,
                        chargeValue=float(chargeValue),
                        priceRangeList=price_range_list,
                        createdOn=datetime.datetime.now(),
                        status=1,
                        holidayPrice=holidayPrice,
                    )
                    new_record.save()
            flash("Setup charge commission Details Updated successfully!", "success")
            data_status["responseStatus"]=1
            return data_status
        else:
            print("form errors",error_list)
            data_status["responseStatus"]=0
            data_status["result"]=error_list
            return data_status
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash(f"Error in upserting record: {str(e)}", "error")
        data_status["responseStatus"]=4
        return data_status


@patterns_configuarations.route("/bulk_payout_update",methods=["POST","GET"])
@adminid_access_token_required
@csrf_protect
def bulk_payout_update():
    data_status = {"responseStatus": 0, "result": ""}
    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()

    existingPayoutsList = []
    form = BulkPayoutUpdateForm(request.form)
    try:
        permissionsList = check_permissions(session.get("adminId"), "switchprofilePermissions")
        if "edit" in permissionsList:
            if request.method =="GET":
                payout_queryset = TransactionAPI.objects(transactionType="Payout",status=1).order_by('-id')
                for each_user in payout_queryset:
                    patternDict = {
                        "apiId":each_user.id,
                        "apiName":each_user.apiName
                    }
                    if patternDict not in existingPayoutsList:
                        existingPayoutsList.append(patternDict)
                return render_template(
                        "super_admin_templates/bulk_payout_update.html",
                        existingPayoutsList=existingPayoutsList
                    )
            elif request.method=="POST":
                if form.validate_on_submit():
                    otp_check_id = request.form.get("otpLogid", "")
                    defaultVerificationId = request.form.get("defaultVerificationId", "")
                    print("otp_check_id",otp_check_id)
                    if not otp_check_id:
                        flash("Invalid Request.")
                        return redirect(url_for("patterns_configuarations.bulk_payout_update")) 
                    
                    otpcheck_queryset = OtpChecks.objects(adminId=adminId,defaultVerificationField=defaultVerificationId, id=str(otp_check_id), status=1).first()
                    
                    if not otpcheck_queryset:
                        flash("Invalid Request.")
                        return redirect(url_for("patterns_configuarations.bulk_payout_update"))
                    # Update OTP status to 2 after verification
                    otpcheck_queryset.update(status=2)

                    updateType=""
                    existingPayoutsIdsList = request.form.getlist("existingPayoutsIdsList")
                    newApiId = request.form.get("newApiId")
                    includeProfilesList = request.form.getlist("includeProfilesList")
                    excludeProfilesList = request.form.getlist("excludeProfilesList")

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

                    if len(includeProfilesList)> 0:
                        updateType="include"
                    elif len(excludeProfilesList)> 0:
                        updateType="exclude"
                    print("includeProfilesList",includeProfilesList)
                    print("excludeProfilesList",excludeProfilesList)
                    print("existingPayoutsIdsList",existingPayoutsIdsList)
                    print("newApiId",newApiId)
                    if existingPayoutsIdsList and newApiId:
                        patterns_queryset=Patterns.objects(payoutPaymentGatewayId__in=existingPayoutsIdsList,status=1).all()
                        admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                        existing_record = patterns_queryset.to_json()
                        message=admin_queryset.userName+" Switch Profile Payout Api updated successfully!"
                        requestData=[patterns_queryset]
                        updatedrequestData=[jsonData]
                        save_admin_log_table = save_admin_logs_data(adminId,None,None,"bulk_payout_update","update",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)

                        patterns_count=0
                        for pattern in patterns_queryset:
                            if updateType == "include":
                                if str(pattern.id) in includeProfilesList:
                                    patterns_count= patterns_count+1 
                                    pattern.payoutPaymentGatewayId = ObjectId(newApiId)
                                    print("pattern.patternId", ObjectId(newApiId))
                                    print("",)
                                    pattern.save()
                            elif updateType == "exclude":
                                if str(pattern.id) not in excludeProfilesList:
                                    patterns_count= patterns_count+1
                                    pattern.payoutPaymentGatewayId = ObjectId(newApiId)
                                    pattern.save()
                            else:
                                patterns_count= patterns_count+1
                                pattern.payoutPaymentGatewayId = ObjectId(newApiId)
                                pattern.save()
                        if patterns_count > 0:
                            flash("Payout Api updated successfully for "+str(patterns_count)+" Patterns!!")
                            data_status["responseStatus"]=1
                            return data_status
                        else:
                            flash("No Profiles with selected Payout Api exist!!")
                            data_status["responseStatus"]=1
                            return data_status
                    else:
                        flash("Required fields are missing!!")
                        data_status["responseStatus"]=4
                        return data_status
                else:
                    print("form errors",form.errors)
                    data_status["result"]=form.errors
                    return data_status
        else:
            flash("The staff member does not have permission to update Switch profile payout api.", "danger")
            data_status["responseStatus"]=4
            return data_status
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash(f"Error in Bulk Payout Update: {str(e)}", "error")
        data_status["responseStatus"]=4
        return data_status


@patterns_configuarations.route("/get_payout_patterns_list",methods=["POST","GET"])
@adminid_access_token_required
@csrf.exempt
def get_payout_patterns_list():
    try:
        data_status = {"responseStatus": 0, "result": ""}
        if not session.get("adminId"):
            return redirect("admin_login")
        adminId=session.get("adminId")

        existingPayoutsIdsList = request.json.get("existingPayoutsIds")
        payoutPatternsList = []
        print("patternName",existingPayoutsIdsList)

        users_queryset=Patterns.objects(payoutPaymentGatewayId__in=existingPayoutsIdsList,status=1).all()
        for user in users_queryset:
            userDict = {
                "id": str(user.id),
                "patternName": user.name,
            }
            payoutPatternsList.append(userDict)

        data_status["responseStatus"] = 1
        data_status["result"] = "ProfileUsers List fetched successfully!"
        data_status["payoutPatternsList"] = payoutPatternsList
        

        return jsonify(data_status), 200
        return redirect(url_for("patterns_configuarations.bulk_profile_update"))

    except Exception as e:
        app.logger.error(traceback.format_exc())
        Flash(f"Error fetching payout options")
        data_status["result"] = "An error occurred while fetching payout options!"
        return jsonify(data_status), 500
    

class AddHolidayDateForm(FlaskForm):
    overrideDate = DateField('',format='%Y-%m-%d',validators=[DataRequired(message="Override Date is required")])
    from_time = FieldList(
        TimeField(
            '',
            format="%H:%M",
            validators=[
                DataRequired(message="From Time is required"),
                Regexp(TIME_PATTERN, message="Enter time in 24-hour format (HH:MM)")
            ]
        ),

    )
    to_time = FieldList(
        TimeField('', format="%H:%M", validators=[
        DataRequired(message="To Time is required"), Regexp(TIME_PATTERN, message="Enter time in 24-hour format (HH:MM)")])
    )

    class Meta:
        csrf = False


@patterns_configuarations.route("/add_holiday_date", methods=["POST", "GET"])
@adminid_access_token_required
@csrf_protect
def add_holiday_date():
    data_status={"responseStatus":0,"result":""}
    try:
        error = None
        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")
        userAgent=""
        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,"holidaydatesPermissions")
        if "add" in permissionsList:
            data_status = {"responseStatus": 0, "result": ""}
            redirectTo = "overrideDates"

            otp_check_id = request.form.get("otpLogid", "")
            print("otp_check_id",otp_check_id)
            if not otp_check_id:
                flash("Invalid Request.")
                return redirect(url_for("patterns_configuarations.get_holiday_dates"))
            
            otpcheck_queryset = OtpChecks.objects(adminId=adminId, id=str(otp_check_id), status=1).first()
            
            if not otpcheck_queryset:
                flash("Invalid Request.")
                return redirect(url_for("patterns_configuarations.get_holiday_dates"))
            # Update OTP status to 2 after verification
            otpcheck_queryset.update(status=2)
 
            # Fetch form data
            print("requestsssssssss", request.form)
            overrideDate = request.form.get('overrideDate')  # Get the override date
            from_times = request.form.getlist('from_time')  # List of from times
            to_times = request.form.getlist('to_time')

            print("overrideDate", overrideDate)
            print("from_times", from_times)
            print("to_times", to_times)

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


            form = AddHolidayDateForm()

            if form.validate_on_submit():


                # Validate input
                if not overrideDate or not from_times or not to_times:
                    data_status['responseStatus']=2
                    data_status['result']="Required fields are missing!!"
                    return data_status

                # Build the timings list
                overridesDateTimings = [{"fromTime": ft, "toTime": tt} for ft, tt in zip(from_times, to_times)]

                admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                if admin_queryset:
                    message=admin_queryset.userName+" "+overrideDate+" Holiday date created successfully!"
                    save_admin_log_table = save_admin_logs_data(adminId,None,None,"add_holiday_date","create",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)

                holiday_table= HolidayDates(
                    holidayDate=overrideDate,
                    holidayDateTimings=overridesDateTimings,
                    status=1,
                    createdOn = datetime.datetime.now()
                ).save()

                flash("Holiday date added successfully!")
                data_status['responseStatus']=1
                return data_status
            else:
                data_status['result']=form.errors
                return data_status
        else:
            flash("The staff member does not have permission to create a Holiday date.", "danger")
            data_status['responseStatus']=4
            return data_status
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("An error occurred while adding the holiday date.")
        data_status['responseStatus']=4
        return data_status





# @patterns_configuarations.route("/add_holiday_date", methods=["POST", "GET"])
# @adminid_access_token_required
# @csrf_protect
# def add_holiday_date():
#     try:
#         error = None
#         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))))))))))))))")

#         loginBrowser = request.headers.get("Sec-Ch-Ua")
#         userAgent=""
#         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,"holidaydatesPermissions")
#         if "add" in permissionsList:
#             data_status = {"responseStatus": 0, "result": ""}
#             redirectTo = "overrideDates"

#             otp_check_id = request.form.get("otpLogid", "")
#             print("otp_check_id",otp_check_id)
#             if not otp_check_id:
#                 flash("Invalid Request.")
#                 return redirect(url_for("patterns_configuarations.get_holiday_dates"))
            
#             otpcheck_queryset = OtpChecks.objects(adminId=adminId, id=str(otp_check_id), status=1).first()
            
#             if not otpcheck_queryset:
#                 flash("Invalid Request.")
#                 return redirect(url_for("patterns_configuarations.get_holiday_dates"))
#             # Update OTP status to 2 after verification
#             otpcheck_queryset.update(status=2)
 
#             # Fetch form data
#             print("requestsssssssss", request.form)
#             overrideDate = request.form.get('overrideDate')  # Get the override date
#             from_times = request.form.getlist('from_time[]')  # List of from times
#             to_times = request.form.getlist('to_time[]') 

#             print("overrideDate", overrideDate)
#             print("from_times", from_times)
#             print("to_times", to_times)

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

#             # Validate input
#             if not overrideDate or not from_times or not to_times:
#                 flash("Required fields are missing!")
#                 return redirect(url_for("patterns_configuarations.get_holiday_dates"))

#             # Build the timings list
#             overridesDateTimings = [{"fromTime": ft, "toTime": tt} for ft, tt in zip(from_times, to_times)]

#             admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
#             if admin_queryset:
#                 message=admin_queryset.userName+" "+overrideDate+" Holiday date created successfully!"
#                 save_admin_log_table = save_admin_logs_data(adminId,None,None,"add_holiday_date","create",actionDate,client_ip,browser,message,requestData,updatedrequestData)

#             holiday_table= HolidayDates(
#                 holidayDate=overrideDate,
#                 holidayDateTimings=overridesDateTimings,
#                 status=1,
#                 createdOn = datetime.datetime.now()
#             ).save()

#             flash("Holiday date added successfully!")
#             return redirect(url_for("patterns_configuarations.get_holiday_dates"))
#         else:
#             flash("Staff member does not have given create holiday date permissions!!")
#             return redirect(url_for("patterns_configuarations.get_holiday_dates"))
#     except Exception as e:
#         app.logger.error(traceback.format_exc())
#         flash("An error occurred while adding the holiday date.")
#         return redirect(url_for("patterns_configuarations.get_holiday_dates"))



@patterns_configuarations.route("/get_holiday_dates",methods=["POST","GET"])
@adminid_access_token_required
def get_holiday_dates():
    try:
        data_status = {"responseStatus": 0, "result":""}
        holidaytimingsList=[]
        available_timings_data={}
        error=None
        snoCount=0
        holidayPage=1
        pagination =  ""

        if not session.get("adminId"):
            return redirect("admin_login")
        adminId = session.get("adminId")

        permissionsList = check_permissions(session.get("adminId"),"holidaydatesPermissions")
        if "view" in permissionsList:
            transactionType =request.args.get("transactionType","")


            holidayPage = request.args.get(get_page_parameter("holidayPage"), type=int, default=1)

            per_page = 20
            start = (holidayPage - 1) * per_page

            total_count=0
            filters = Q(status__in=[0, 1])

            total_count = HolidayDates.objects(filters).count()

            holiday_queryset = ( 
                    HolidayDates.objects(filters)
                    .only("id","holidayDate","holidayDateTimings","status")
                    .order_by("-id")
                    .skip(start)
                    .limit(per_page)
                )
            
            snoCount = start

            holidaytimingsList = list(holiday_queryset)

            pagination = Pagination(holidayPage=holidayPage, total=total_count, per_page=per_page, page_parameter ="holidayPage", alignment="right", record_name="holiday")


            return render_template(
                        "super_admin_templates/holiday_dates_list.html",
                        holidaytimingsList=holidaytimingsList,
                        pagination=pagination,
                        snoCount = snoCount,
                        holidayPage = holidayPage
                    )
        else:
            flash("The staff member does not have permission to view Holiday dates.", "danger")
            return redirect(url_for("admin.dashboard"))

    except Exception as e:
        app.logger.error(traceback.format_exc())
        data_status["result"] = "An error occurred while fetching Available Options!"
        return render_template(
                        "super_admin_templates/holiday_dates_list.html",
                        holidaytimingsList=holidaytimingsList,
                        error=error,
                        pagination=pagination,
                        snoCount = snoCount,
                        holidayPage = holidayPage
                    )


# @patterns_configuarations.route("/get_holiday_dates",methods=["POST","GET"])
# @adminid_access_token_required
# def get_holiday_dates():
#     try:
#         data_status = {"responseStatus": 0, "result":""}
#         holidaytimingsList=[]
#         available_timings_data={}
#         error=None

#         if not session.get("adminId"):
#             return redirect("admin_login")
#         adminId = session.get("adminId")

#         permissionsList = check_permissions(session.get("adminId"),"holidaydatesPermissions")
#         if "view" in permissionsList:
#             transactionType =request.args.get("transactionType","")

#             holiday_queryset = HolidayDates.objects(status__in=[1,0]).all()

#             for each_override_list in holiday_queryset:
#                 timings_str_list=[]
#                 print("timingsList",each_override_list)
#                 overrideTimingsList = each_override_list.holidayDateTimings

#                 for each_rec in overrideTimingsList:
#                     timings_str_list.append(each_rec.get("fromTime") + " - " +each_rec.get("toTime"))
#                 timings_str_list = ', '.join(timings_str_list)
#                 holidaytimingsList.append({
#                     "id": each_override_list.id,
#                     "holidayDate": each_override_list.holidayDate,
#                     "formattedTimingsList": timings_str_list,
#                     "timingsList": each_override_list.holidayDateTimings,

#                 })
            
#             print("holidaytimingsList",holidaytimingsList )

#             return render_template(
#                         "super_admin_templates/holiday_dates_list.html",
#                         holidaytimingsList=holidaytimingsList,
#                         error=error
#                     )
#         else:
#             flash("Staff member does not have given view holiday dates permissions!!")
#             return redirect(url_for("admin.dashboard"))

#     except Exception as e:
#         app.logger.error(traceback.format_exc())
#         data_status["result"] = "An error occurred while fetching Available Options!"
#         return render_template(
#                         "super_admin_templates/holiday_dates_list.html",
#                         holidaytimingsList=holidaytimingsList,
#                         error=error
#                     )

@patterns_configuarations.route("/delete_holiday_date", methods=["POST"])
@adminid_access_token_required
@csrf_protect
def delete_holiday_date():
    try:
        existing_record=""
        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")
        userAgent=""
        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)

        requestData = [existing_record]
        updatedrequestData = [jsonData]

        permissionsList = check_permissions(session.get("adminId"),"holidaydatesPermissions")
        if "delete" in permissionsList:
            data_status = {"responseStatus": 0, "result": ""}
            
            dateId = request.args.get("dateId")
            holidayPage = request.args.get(get_page_parameter("holidayPage"), type=int, default=1)

            action = request.form.get("action", "").strip()
            data = request.form.to_dict()

            # Step 1: Handle OTP Generation
           
            otp_check_id = request.form.get("otpLogid", "")
            print("otp_check_id",otp_check_id)
            if not otp_check_id:
                flash("Invalid Request.")
                return redirect(url_for("patterns_configuarations.get_patterns_configuarations_list",holidayPage=holidayPage))

            otpcheck_queryset = OtpChecks.objects(adminId=adminId, id=str(otp_check_id), status=1).first()

            if not otpcheck_queryset:
                flash("Invalid Request.")
                return redirect(url_for("patterns_configuarations.get_holiday_dates",holidayPage=holidayPage))
            # Update OTP status to 2 after verification
            otpcheck_queryset.update(status=2)


            # Step 4: Proceed with Deletion **Only after OTP verification**
            if not dateId:
                flash("Holiday Id is required!")
                return redirect(url_for("patterns_configuarations.get_holiday_dates",holidayPage=holidayPage))

            available_timings_queryset = HolidayDates.objects(id=dateId,status=1).first()
            existing_record = available_timings_queryset.to_json()

            if not available_timings_queryset:
                flash("No available timings found!")
                return redirect(url_for("patterns_configuarations.get_holiday_dates",holidayPage=holidayPage))

            overridesDatesList = available_timings_queryset.update(status=2)
            admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
            message=admin_queryset.userName+" Holiday date deleted successfully!"
            save_admin_log_table = save_admin_logs_data(adminId,None,None,"delete_holiday_date","delete",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)

            flash("Holiday date deleted successfully!")
            return redirect(url_for("patterns_configuarations.get_holiday_dates",holidayPage=holidayPage))
        else:
            flash("The staff member does not have permission to delete Holiday date.", "danger")
            return redirect(url_for("patterns_configuarations.get_holiday_dates",holidayPage=holidayPage))
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("An error occurred while deleting the override date.")
        return redirect(url_for("patterns_configuarations.get_holiday_dates",holidayPage=holidayPage))


@patterns_configuarations.route("/update_holiday_date", methods=["POST", "GET"])
@adminid_access_token_required
@csrf_protect
def update_holiday_date():
    data_status={"responseStatus":0,"result":""}
    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")
    userAgent=""
    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()

    try:
        permissionsList = check_permissions(session.get("adminId"),"holidaydatesPermissions")
        if "edit" in permissionsList:
            redirectTo = "overrides_dates_list"
            dateId = request.args.get("dateId")


            action = request.form.get("action", "").strip()
            data = request.form.to_dict()
            # Step 1: Handle OTP Generation
            
            otp_check_id = request.form.get("otpLogid", "")
            print("otp_check_id",otp_check_id)
            if not otp_check_id:
                flash("Invalid Request.")
                return redirect(url_for("patterns_configuarations.get_holiday_dates"))

            otpcheck_queryset = OtpChecks.objects(adminId=adminId, id=str(otp_check_id), status=1).first()

            if not otpcheck_queryset:
                flash("Invalid Request.")
                return redirect(url_for("patterns_configuarations.get_holiday_dates"))
            # Update OTP status to 2 after verification
            otpcheck_queryset.update(status=2)


            # Fetch form data
            holidayDate = request.form.get("overrideDate")        # The date to identify the record to update
            from_times = request.form.getlist("from_time")       # New 'from' times
            to_times = request.form.getlist("to_time")           # New 'to' times

            print("holidayDate", holidayDate)
            print("from_times", from_times)
            print("to_times", to_times)

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

            form = AddHolidayDateForm(request.form,current_id=dateId)

            if form.validate_on_submit():


                # Validate input
                if not holidayDate or not from_times or not to_times:
                    data_status["responseStatus"]=2
                    data_status["result"]="Required fields are missing."
                    return data_status

                # Build the new timings list
                holidayDateTimings = [{"fromTime": ft, "toTime": tt} for ft, tt in zip(from_times, to_times)]

                # Fetch the database record
                available_timings_queryset = HolidayDates.objects(id=dateId,status=1).first()
                existing_record = available_timings_queryset.to_json()
                admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                message=admin_queryset.userName+" "+holidayDate+" holiday date updated successfully!"
                requestData=[existing_record]
                updatedrequestData=[jsonData]
                save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_holiday_date","update",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude)

                if not available_timings_queryset:
                    flash("No available timings found!")
                    data_status["responseStatus"]=4
                    return data_status

                # # Find and update the matching record in overridesDatesList
                # overridesDatesList = available_timings_queryset.overridesDatesList
                # for override in overridesDatesList:
                #     if override["holidayDate"] == holidayDate:  # Match the date
                #         override["timingsList"] = updatedTimingsList  # Update timings list
                #         break
                # else:
                #     flash("No matching holiday date found!")
                #     return redirect(url_for("patterns_configuarations.get_holiday_dates"))

                # Save the updated list back to the database
                available_timings_queryset.update(holidayDate=holidayDate,holidayDateTimings=holidayDateTimings)

                flash("holiday date updated successfully!")
                data_status["responseStatus"]=1
                return data_status
            else:
                    data_status['result']=form.errors
                    return data_status
        else:
            flash("The staff member does not have permission to update Holiday date.", "danger")
            data_status['responseStatus']=4
            return data_status
           
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash("An error occurred while updating the holiday date.")
        data_status['responseStatus']=4
        return data_status

def validate_site_available_timings(
    siteId, transactionType, is_enabled,
    sun_enabled, sun_from_times, sun_to_times,
    mon_enabled, mon_from_times, mon_to_times,
    tue_enabled, tue_from_times, tue_to_times,
    wed_enabled, wed_from_times, wed_to_times,
    thu_enabled, thu_from_times, thu_to_times,
    fri_enabled, fri_from_times, fri_to_times,
    sat_enabled, sat_from_times, sat_to_times
):
    errors = {}

    if not siteId:
        errors["siteId"] = "Site ID is required."
    if not transactionType:
        errors["transactionType"] = "Transaction type is required."

    days = {
        "Sunday": (sun_enabled, sun_from_times, sun_to_times),
        "Monday": (mon_enabled, mon_from_times, mon_to_times),
        "Tuesday": (tue_enabled, tue_from_times, tue_to_times),
        "Wednesday": (wed_enabled, wed_from_times, wed_to_times),
        "Thursday": (thu_enabled, thu_from_times, thu_to_times),
        "Friday": (fri_enabled, fri_from_times, fri_to_times),
        "Saturday": (sat_enabled, sat_from_times, sat_to_times),
    }

    for day, (enabled, from_list, to_list) in days.items():
        if enabled:
            if not from_list or not to_list:
                errors[f"{day}"] = f"{day} timings are missing."
                continue

            if len(from_list) != len(to_list):
                errors[f"{day}_length"] = f"{day} has mismatched from/to times."
                continue
            seen_slots = set()
            for i, (from_time, to_time) in enumerate(zip(from_list, to_list)):
                if not from_time.strip():
                    errors[f"{day}_from_{i}"] = f"Missing from time for {day}, slot {i+1}."
                if not to_time.strip():
                    errors[f"{day}_to_{i}"] = f"Missing to time for {day}, slot {i+1}."
                if from_time and to_time:
                    if from_time >= to_time:
                        errors[f"{day}_order_{i}"] = f"'From' time must be earlier than 'To' time on {day}, slot {i+1}."
                    
                    time_pair = (from_time, to_time)
                    if time_pair in seen_slots:
                        errors[f"{day}_duplicate_{i}"] = f"Duplicate time slot on {day}, slot {i+1}: {from_time} - {to_time}."
                    else:
                        seen_slots.add(time_pair)

    print("len()",len(errors) == 0)
    print("lenaaaaaaaaaaaaaaaaa",errors)
    return (len(errors) == 0), errors

@patterns_configuarations.route("/sites_available_timings",methods=["POST","GET"])
@adminid_access_token_required
def sites_available_timings():
    if not session.get("adminId"):
        return redirect("admin_login")
    adminId = session.get("adminId")
    redirectTo =request.args.get("redirectval","timingsList")
    error_messages={}
    data_status={"responseStatus":0,"result":""}
    form = ""
    transactionType =""
    siteId =""
    payinTimingsList=[]
    available_timings_data={}
    siteName=""
    sunAvailableTimingsList=[]
    permissionsList = check_permissions(session.get("adminId"),"payinAvailableTimePermissions")

    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()

    if "view" in permissionsList:
        try:
            transactionType =request.args.get("transactionType","")
            siteId =request.args.get("siteId","")
            print(transactionType,"((((((((((((transactionType))))))))))))")
            print(siteId,"((((((((((((siteId))))))))))))")

            # if not siteId or not transactionType:
            #     flash("Invalid Site Id!")
            #     return redirect(url_for("multiple_app_sites.get_multiple_app_sites"))

            available_timings_queryset0 = MultipleAppSitesAvailableTimings.objects(transactionType=transactionType,siteId=str(siteId),status=1).first()
            available_timings_data_list=[]
            overridesDatesList = []
            timings_str_list=[]
            overrideTimingsList=[]
            # If the record doesn't exist, create a new one
            if not available_timings_queryset0:
                available_timings_queryset1 = MultipleAppSitesAvailableTimings(
                    isEnabled =  False,
                    sunEnabled = False,
                    sunAvailableTimingsList = [],
                    monEnabled = False,
                    monAvailableTimingsList = [],
                    tueEnabled = False,
                    tueAvailableTimingsList = [],
                    wedEnabled = False,
                    wedAvailableTimingsList = [],
                    thuEnabled = False,
                    thuAvailableTimingsList = [],
                    friEnabled = False,
                    friAvailableTimingsList = [],
                    satEnabled = False,
                    satAvailableTimingsList = [],
                    overridesDatesList = [],
                    transactionType=transactionType,  # Ensure it's for "payout"
                    siteId=siteId,  
                    createdOn=datetime.datetime.now(),
                    status=1
                )
                available_timings_queryset1.save()
            print("")
            
            if request.method == "GET":

                available_timings_queryset = MultipleAppSitesAvailableTimings.objects(transactionType=transactionType,siteId=siteId,status=1).first()

                time_list = available_timings_queryset.overridesDatesList
                # print("time_list",time_list)

                for each_override_list in time_list:
                    timings_str_list=[]
                    # print("timingsList",each_override_list)
                    overrideTimingsList = each_override_list.get("timingsList")
                    for each_rec in overrideTimingsList:
                        timings_str_list.append(each_rec.get("fromTime") + " - " +each_rec.get("toTime"))
                    timings_str_list = ', '.join(timings_str_list)
                    overridesDatesList.append({
                        "overrideDate": each_override_list.get("overrideDate"),
                        "formattedTimingsList": timings_str_list,
                        "timingsList": each_override_list.get("timingsList"),

                    })
                # print("overridesDatesListoverridesDatesListoverridesDatesList",overridesDatesList)

                is_enabled = available_timings_queryset.isEnabled
                sundayDict={
                    "day":"Sunday",
                    "is_enabled":available_timings_queryset.sunEnabled,
                    "timingsList":available_timings_queryset.sunAvailableTimingsList
                }
                available_timings_data_list.append(sundayDict)

                mondayDict={
                    "day":"Monday",
                    "is_enabled":available_timings_queryset.monEnabled,
                    "timingsList":available_timings_queryset.monAvailableTimingsList
                }
                available_timings_data_list.append(mondayDict)

                tuesdayDict={
                    "day":"Tuesday",
                    "is_enabled":available_timings_queryset.tueEnabled,
                    "timingsList":available_timings_queryset.tueAvailableTimingsList
                }
                available_timings_data_list.append(tuesdayDict)

                wednesdayDict={
                    "day":"Wednesday",
                    "is_enabled":available_timings_queryset.wedEnabled,
                    "timingsList":available_timings_queryset.wedAvailableTimingsList
                }
                available_timings_data_list.append(wednesdayDict)

                thursdayDict={
                    "day":"Thursday",
                    "is_enabled":available_timings_queryset.thuEnabled,
                    "timingsList":available_timings_queryset.thuAvailableTimingsList
                }
                available_timings_data_list.append(thursdayDict)

                fridayDict={
                    "day":"Friday",
                    "is_enabled":available_timings_queryset.friEnabled,
                    "timingsList":available_timings_queryset.friAvailableTimingsList
                }
                available_timings_data_list.append(fridayDict)

                saturdayDict={
                    "day":"Saturday",
                    "is_enabled":available_timings_queryset.satEnabled,
                    "timingsList":available_timings_queryset.satAvailableTimingsList
                }
                available_timings_data_list.append(saturdayDict)
                
                # print("dataaaaaaaa",available_timings_data_list )
                # print("overridesDatesList",overridesDatesList )

                if siteId:
                    site_queryset = MultipleAppSites.objects(id=siteId).first()
                    siteName = site_queryset.siteTitle

                return render_template(
                            "super_admin_templates/sites_available_timings.html",
                            payinTimingsList=payinTimingsList,
                            redirectval=redirectTo,
                            available_timings_data_list=available_timings_data_list,
                            is_enabled=is_enabled,
                            siteId=siteId,
                            siteName=siteName,
                            overridesDatesList=overridesDatesList,
                            transactionType=transactionType
                        )

            elif request.method == "POST":
                action = request.form.get("action", "").strip()
                data = request.form.to_dict()
                # Step 1: Handle OTP Generation
                
                otp_check_id = request.form.get("otpLogid", "")
                print("otp_check_id",otp_check_id)
                if not otp_check_id:
                    flash("Invalid Request.")
                    data_status["responseStatus"]=4
                    return data_status
                   

                otpcheck_queryset = OtpChecks.objects(adminId=adminId, id=str(otp_check_id), status=1).first()

                if not otpcheck_queryset:
                    flash("Invalid Request.")
                    data_status["responseStatus"]=4
                    return data_status
                    
                # Update OTP status to 2 after verification
                otpcheck_queryset.update(status=2)


                print("request.form ",request.form)
                transactionType =request.args.get("transactionType","")
                siteId =request.args.get("siteId","")
                redirectTo ="timingsList"
                is_enabled = request.form.get('is_enabled') == 'True'
                sun_enabled = request.form.get('Sunday_is_enabled')== 'True'
                sun_from_times = request.form.getlist('from_time_Sunday[]')
                sun_to_times = request.form.getlist('to_time_Sunday[]')

                mon_enabled = request.form.get('Monday_is_enabled') == 'True'
                mon_from_times = request.form.getlist('from_time_Monday[]')
                mon_to_times = request.form.getlist('to_time_Monday[]')

                tue_enabled = request.form.get('Tuesday_is_enabled') == 'True'
                tue_from_times = request.form.getlist('from_time_Tuesday[]')
                tue_to_times = request.form.getlist('to_time_Tuesday[]')

                wed_enabled = request.form.get('Wednesday_is_enabled') == 'True'
                wed_from_times = request.form.getlist('from_time_Wednesday[]')
                wed_to_times = request.form.getlist('to_time_Wednesday[]')

                thu_enabled = request.form.get('Thursday_is_enabled') == 'True'
                thu_from_times = request.form.getlist('from_time_Thursday[]')
                thu_to_times = request.form.getlist('to_time_Thursday[]')

                fri_enabled = request.form.get('Friday_is_enabled') == 'True'
                fri_from_times = request.form.getlist('from_time_Friday[]')
                fri_to_times = request.form.getlist('to_time_Friday[]')

                sat_enabled = request.form.get('Saturday_is_enabled') == 'True'
                sat_from_times = request.form.getlist('from_time_Saturday[]')
                sat_to_times = request.form.getlist('to_time_Saturday[]')

                jsonData = request.form.to_dict(flat=True)
                requestData = [jsonData]
                updatedrequestData = [jsonData]
                is_valid, error_list = validate_site_available_timings(
                    siteId, transactionType, is_enabled, sun_enabled, sun_from_times, sun_to_times,
                    mon_enabled, mon_from_times, mon_to_times,
                    tue_enabled, tue_from_times, tue_to_times,
                    wed_enabled, wed_from_times, wed_to_times,
                    thu_enabled, thu_from_times, thu_to_times,
                    fri_enabled, fri_from_times, fri_to_times,
                    sat_enabled, sat_from_times, sat_to_times
                )
                print("is valid", is_valid)
                print("errorrrrvalid", error_list)
                
                if is_valid:
                    admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                    if admin_queryset:
                        message=admin_queryset.userName+" "+transactionType+" Site Available times created successfully!"
                        save_admin_log_table = save_admin_logs_data(adminId,None,None,"sites_available_timings","create",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 
                    available_timings_queryset = MultipleAppSitesAvailableTimings.objects(transactionType=transactionType,siteId=siteId,status=1).first()

                    if available_timings_queryset:
                        # print("inside updte")
                        # print(f"""
                        # Sunday Enabled: {sun_enabled}, Sunday From Times: {sun_from_times}, Sunday To Times: {sun_to_times}
                        # Monday Enabled: {mon_enabled}, Monday From Times: {mon_from_times}, Monday To Times: {mon_to_times}
                        # Tuesday Enabled: {tue_enabled}, Tuesday From Times: {tue_from_times}, Tuesday To Times: {tue_to_times}
                        # Wednesday Enabled: {wed_enabled}, Wednesday From Times: {wed_from_times}, Wednesday To Times: {wed_to_times}
                        # Thursday Enabled: {thu_enabled}, Thursday From Times: {thu_from_times}, Thursday To Times: {thu_to_times}
                        # Friday Enabled: {fri_enabled}, Friday From Times: {fri_from_times}, Friday To Times: {fri_to_times}
                        # Saturday Enabled: {sat_enabled}, Saturday From Times: {sat_from_times}, Saturday To Times: {sat_to_times}
                        # """,type(sun_enabled))
                        available_timings_queryset.isEnabled = is_enabled
                        available_timings_queryset.sunEnabled = sun_enabled
                        # available_timings_queryset.sunAvailableTimingsList = [{"fromTime": ft, "toTime": tt} for ft, tt in zip(sun_from_times, sun_to_times) if ft and tt]
                        available_timings_queryset.sunAvailableTimingsList = [
                                {"fromTime": ft.strip(), "toTime": tt.strip()} 
                                for ft, tt in zip(sun_from_times, sun_to_times) 
                                if ft.strip() and tt.strip()
                            ]

                        available_timings_queryset.monEnabled = mon_enabled
                        available_timings_queryset.monAvailableTimingsList = [{"fromTime": ft, "toTime": tt} for ft, tt in zip(mon_from_times, mon_to_times)  if ft and tt]
                        available_timings_queryset.tueEnabled = tue_enabled
                        available_timings_queryset.tueAvailableTimingsList = [{"fromTime": ft, "toTime": tt} for ft, tt in zip(tue_from_times, tue_to_times)  if ft and tt]
                        available_timings_queryset.wedEnabled = wed_enabled
                        available_timings_queryset.wedAvailableTimingsList = [{"fromTime": ft, "toTime": tt} for ft, tt in zip(wed_from_times, wed_to_times)  if ft and tt]
                        available_timings_queryset.thuEnabled = thu_enabled
                        available_timings_queryset.thuAvailableTimingsList = [{"fromTime": ft, "toTime": tt} for ft, tt in zip(thu_from_times, thu_to_times)  if ft and tt]
                        available_timings_queryset.friEnabled = fri_enabled
                        available_timings_queryset.friAvailableTimingsList = [{"fromTime": ft, "toTime": tt} for ft, tt in zip(fri_from_times, fri_to_times)  if ft and tt]
                        available_timings_queryset.satEnabled = sat_enabled
                        available_timings_queryset.satAvailableTimingsList = [{"fromTime": ft, "toTime": tt} for ft, tt in zip(sat_from_times, sat_to_times)  if ft and tt]
                        available_timings_queryset.status = 1
                        available_timings_queryset.createdOn = datetime.datetime.now()
                        available_timings_queryset.save()
                    flash("Available Timings saved successfully", "success")
                    data_status['responseStatus']=1
                    return data_status
                    # flash("site available timings saved successfully!!","success")
                    # return redirect(url_for("patterns_configuarations.sites_available_timings",redirectval=redirectTo,transactionType=transactionType,siteId=siteId))
                   
                else:

                    # Flash error messages from the validation result
                    for field, message in error_list.items():
                        flash(message, "danger")
                    
                    data_status["responseStatus"] = 4
                    data_status["result"] = error_list
                    return data_status
                
        except Exception as e:
            app.logger.error(traceback.format_exc())
            error = "An error occurred while fetching site Available Options!"
        return redirect(url_for("patterns_configuarations.sites_available_timings",error=error,redirectval=redirectTo,transactionType=transactionType,siteId=siteId))

    else:
        flash("Staff member does not have given view site available timings permissions!!")
        return redirect(url_for("admin.dashboard"))


@patterns_configuarations.route("/get_on_demand_settlement_charges_list",methods=["POST","GET"])
@adminid_access_token_required
def get_on_demand_settlement_charges_list():
    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))))))))))))))")
    loginBrowser = request.headers.get("Sec-Ch-Ua")
    userAgent=""
    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()

    total_count=0
    pagination=None
    settlementChargesList=[]
    snoCount=0
    ondemandSettlementPage=None
    permissionsList = check_permissions(session.get("adminId"),"onDemandSettlementChargesPermission")
    if "view" in permissionsList:
        try:
            data_status = {"responseStatus": 0, "result": ""}
            redirectTo = "overrides_dates_list"
            dateId = request.args.get("dateId")

            ondemandSettlementPage = request.args.get(get_page_parameter("ondemandSettlementPage"), type=int, default=1)
            per_page = 20
            start = (ondemandSettlementPage - 1) * per_page
            total_count=0

            action = request.form.get("action", "").strip()
            data = request.form.to_dict()
            # Step 1: Handle OTP Generation

            pagination = Pagination(ondemandSettlementPage=ondemandSettlementPage, total=total_count, per_page=per_page,page_parameter ="ondemandSettlementPage", alignment="right", record_name="documents")

            settlement_charges_queryset = (
                        OnDemandSettlementCharges.objects()
                        .order_by("-id")
                        .skip(start)
                        .limit(per_page)
                    )
            settlementChargesList=list(settlement_charges_queryset)


            return render_template("super_admin_templates/on_demand_settlement_charges_list.html",
                    pagination=pagination,
                    settlementChargesList=settlementChargesList,
                    snoCount=snoCount,
                    ondemandSettlementPage = ondemandSettlementPage,)
            
               
        except Exception as e:
            app.logger.error(traceback.format_exc())
            error = "An error occurred while updating the On Demand Settlement Charge."
            return render_template("super_admin_templates/on_demand_settlement_charges_list.html",
                    error = error,
                    pagination = pagination,
                    settlementChargesList = settlementChargesList,
                    snoCount = snoCount,
                    ondemandSettlementPage = ondemandSettlementPage
                    )
    else:
        flash("The staff member does not have permission to view On demand settlement charge.", "danger")
        return redirect(url_for("admin.dashboard"))
       

@patterns_configuarations.route("/add_on_demand_settlement_charge", methods=["POST", "GET"])
@adminid_access_token_required
@csrf_protect
def add_on_demand_settlement_charge():
    data_status={"responseStatus":0,"result":""}
    if not session.get("adminId"):
        flash("session expired.Please login again.")
        data_status["responseStatus"]=4
        return data_status
    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()
    
    try:
        permissionsList = check_permissions(session.get("adminId"),"onDemandSettlementChargesPermission")
        if "add" in permissionsList:
            # documentId = request.args.get("documentId","")
            document_dict = {}
            transactionAPIsList=[]
            print(" in add on demand")
            if request.method == "GET":
                print(" in add on demand, get reuqedd")
                transaction_API_queryset = TransactionAPI.objects(status__in=[0, 1]).order_by('-id').all()
                for each_transaction_api in transaction_API_queryset:
                    service_grouping_dict = {
                        "id": str(each_transaction_api.id),
                        "apiName": each_transaction_api.apiName
                    }
                    transactionAPIsList.append(service_grouping_dict)
                return render_template("super_admin_templates/add_on_demand_settlement_charge.html",transactionAPIsList = transactionAPIsList
                                    #    form=form
                                        )
            if request.method == "POST":
                print(" in add on demand post request")
                chargeName = request.form.get("chargeName","")
                paymentGatewayIdsList = request.form.getlist("paymentGatewayIdsList")
                holidayCalculationvalue = request.form.get("holidayCalculation","")
                maxDays = request.form.get("maxDays",0)
                priceType = request.form.get("priceType","")
                chargeType = request.form.get("chargeType","")
                chargeValue = request.form.get("chargeValue",0)
                gstInclude = request.form.get("gstInclude","")
                gstValue = request.form.get("gstValue",0)
                tdsInclude = request.form.get("tdsInclude","")
                tdsValue = request.form.get("tdsValue",0)

                print("((((((((((((((((((((((((((((((((((((request from))))))))))))))))))))))))))))))))))))",request.form)
                
                jsonData = request.form.to_dict(flat=True)
                requestData = [jsonData]
                updatedrequestData = [jsonData]
  
                holidayCalculation=False
                if holidayCalculationvalue =="True":
                    holidayCalculation = True

                form = OnDemandSettlementChargesForm()

                if form.validate_on_submit():
                    try:
                        admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                        if admin_queryset:
                            message=admin_queryset.userName+" "+chargeName+" On Demand Settlement Charge Created successfully!"
                            save_admin_log_table = save_admin_logs_data(adminId,None,None,"add_on_demand_settlement_charge","create",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 
                            print("((((((((((((save_admin_log_table))))))))))))",save_admin_log_table)
                    
                            # document_queryset = OnDemandSettlementCharges.objects(status=1).order_by("-id").first()
                            # if document_queryset:
                            document_table = OnDemandSettlementCharges(
                                chargeName=chargeName,
                                paymentGatewayIdsList=paymentGatewayIdsList,
                                holidayCalculation=holidayCalculation,
                                maxDays=maxDays,
                                priceType=priceType,
                                chargeType=chargeType,
                                chargeValue=chargeValue,
                                gstInclude=gstInclude,
                                gstValue=gstValue,
                                tdsInclude=tdsInclude,
                                tdsValue=tdsValue,
                                status=1,
                                createdOn = datetime.datetime.now()
                                )
                            save_table = document_table.save()
                            flash("On Demand Settlement Charge created successfully!","success")
                            data_status["responseStatus"]=1
                            return data_status
                        else:
                            flash("Invalid request", "danger")
                            data_status["responseStatus"]=4
                            return data_status
                    except Exception as e:
                        flash("Unable to save On Demand Settlement Charge.", "danger")
                        app.logger.error(traceback.format_exc())
                        data_status['responseStatus']=4
                        return data_status
                else:
                    print("form.errors",form.errors)
                    data_status['result']=form.errors
                    print("(((((((((((((((((((((((((((fromerrors)))))))))))))))))))))))))))",form.errors)
                    return data_status        
            else:
                flash("Invalid request. Please try again.", "danger")
                data_status["responseStatus"]=4
                return data_status
        else:
            flash("The staff member does not have permission to create a On demand settlement charge.", "danger")
            data_status['responseStatus']=4
            return data_status
           
    except Exception as e:
        app.logger.error(traceback.format_exc())
        error = "Unable to add On Demand Settlement Charge details!!"
        flash(error)
        data_status["responseStatus"]=4
        return data_status


@patterns_configuarations.route("/update_on_demand_settlement_charge", methods=["POST", "GET"])
@adminid_access_token_required
@csrf_protect
def update_on_demand_settlement_charge():
    data_status={"responseStatus":0,"result":""}
    if not session.get("adminId"):
        flash("session expired.Please login again.")
        data_status["responseStatus"]=4
        return data_status
    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()
    # form = documentListForm()

    
    
    try:
        permissionsList = check_permissions(session.get("adminId"),"onDemandSettlementChargesPermission")
        if "edit" in permissionsList:
            # documentId = request.args.get("documentId","")
            document_dict = {}
            transactionAPIsList=[]
            print(" in update on demand")

            chargeId = request.args.get("chargeId")
            print("(((((((((chargeId)))))))))",chargeId)
            
            if request.method == "GET":
                print(" in update on demand, get reuqedd")
                transaction_API_queryset = TransactionAPI.objects(status__in=[0, 1]).order_by('-id').all()
                for each_transaction_api in transaction_API_queryset:
                    service_grouping_dict = {
                        "id": str(each_transaction_api.id),
                        "apiName": each_transaction_api.apiName
                    }
                    transactionAPIsList.append(service_grouping_dict)
                
                document_queryset = OnDemandSettlementCharges.objects(id=chargeId,status=1).order_by("-id").first()
                if not document_queryset:
                    flash("Invalid On Demand Settlement Charge Id!!")
                    return redirect(url_for("patterns_configuarations.get_on_demand_settlement_charges_list"))

                chargeDict = {
                    "id": document_queryset.id,
                    "chargeName": document_queryset.chargeName,
                    "paymentGatewayIdsList": document_queryset.paymentGatewayIdsList,
                    "checkTransactionAPIIds": [ str(i.id) for i in document_queryset.paymentGatewayIdsList],
                    "holidayCalculation": document_queryset.holidayCalculation,
                    "maxDays": document_queryset.maxDays,
                    "priceType": document_queryset.priceType,
                    "chargeType": document_queryset.chargeType,
                    "chargeValue": document_queryset.chargeValue,
                    "gstInclude": document_queryset.gstInclude,
                    "gstValue": document_queryset.gstValue,
                    "tdsInclude": document_queryset.tdsInclude,
                    "tdsValue": document_queryset.tdsValue,
                }
                print("chargeDict",chargeDict)
                return render_template("super_admin_templates/update_on_demand_settlement_charge.html",transactionAPIsList = transactionAPIsList,chargeDict=chargeDict
                                    #    form=form
                                        )
                

            if request.method == "POST":
                print(" in update on demand post request")
                print("(((((((((charge)))))))))",chargeId)

                chargeName = request.form.get("chargeName","")
                paymentGatewayIdsList = request.form.getlist("paymentGatewayIdsList")
                holidayCalculationvalue = request.form.get("holidayCalculation","")
                maxDays = request.form.get("maxDays","")
                priceType = request.form.get("priceType","")
                chargeType = request.form.get("chargeType","")
                chargeValue = request.form.get("chargeValue","")
                gstInclude = request.form.get("gstInclude","")
                gstValue = request.form.get("gstValue","")
                tdsInclude = request.form.get("tdsInclude","")
                tdsValue = request.form.get("tdsValue","")


                form = OnDemandSettlementChargesForm(request.form,current_id=chargeId)
                
                
                if form.validate_on_submit():

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

                    try:
                        admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                        if admin_queryset:
                            message=admin_queryset.userName+" "+chargeName+"On Demand Settlement Charge Updated successfully!"
                            save_admin_log_table = save_admin_logs_data(adminId,None,None,"add_on_demand_settlement_charge","create",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 

                            paymentGatewayIdsList=[ObjectId(i) for i in paymentGatewayIdsList]
                            print("((((((((((((paymentGatewayIdsList))))))))))))",paymentGatewayIdsList)
                            holidayCalculation=False
                            if holidayCalculationvalue =="True":
                                holidayCalculation = True

                            document_queryset = OnDemandSettlementCharges.objects(id=chargeId,status=1).order_by("-id").first()
                            if document_queryset:
                                document_queryset.update(
                                    chargeName=chargeName,
                                    paymentGatewayIdsList=paymentGatewayIdsList,
                                    holidayCalculation=holidayCalculation,
                                    maxDays=maxDays,
                                    priceType=priceType,
                                    chargeType=chargeType,
                                    chargeValue=chargeValue,
                                    gstInclude=gstInclude,
                                    gstValue=gstValue,
                                    tdsInclude=tdsInclude,
                                    tdsValue=tdsValue
                                    )
                                flash("On Demand Settlement Charge Updated successfully!","success")
                                data_status["responseStatus"]=1
                                return data_status
                            else:
                                flash("Invalid Charge Id", "danger")
                                data_status["responseStatus"]=4
                                return data_status
                        else:
                            flash("Invalid request", "danger")
                            data_status["responseStatus"]=4
                            return data_status
                    except Exception as e:
                        flash("Unable to Update On Demand Settlement Charge.", "danger")
                        app.logger.error(traceback.format_exc())
                        data_status['responseStatus']=4
                        return data_status
                else:
                    data_status['result']=form.errors
                    print("(((((((((((((((((((((((((((fromerrors)))))))))))))))))))))))))))",form.errors)
                    return data_status        
            else:
                flash("Invalid request. Please try again.", "danger")
                data_status["responseStatus"]=4
                return data_status
        else:
            flash("The staff member does not have permission to update On demand settlement charge.", "danger")
            data_status["responseStatus"]=4
            return data_status
            
    except Exception as e:
        app.logger.error(traceback.format_exc())
        error = "Unable to update On Demand Settlement Charge details!!"
        flash(error)
        data_status["responseStatus"]=4
        return data_status


@patterns_configuarations.route("/service_payment_setup_table", methods=["POST", "GET"])
@adminid_access_token_required
def service_payment_setup_table():
    if not session.get("adminId"):
        return redirect("admin_login")
    # Initialize lists
    commissionsList = []
    transactionAPIsList = []
    paymentsModeList = []
    subPaymentsModeList = []
    error = None
    success_message = None
    editable = False
    update = False
    setup_charge_commission={}
    setup_charge_commission_dict={}
    setup_charge_commission_list=[]
    price_ranges = []
    servicePaymentType=""
    showData=False
    paymentModeName = ""
    txnName = ""
    form = PaymentSetupChargeSearchForm(request.args)
    adminId = session.get("adminId")
    redirectTo = request.args.get("redirectTo", "Commission")
    permissionsList = check_permissions(session.get("adminId"), "servicePaymentSetupChargeCommissionTableListPermissions")
    if "view" in permissionsList:
        
        try:
            action = request.form.get("action", "").strip()
            data = request.form.to_dict()
            # Step 1: Handle OTP Generation
           
            # otp_check_id = request.form.get("otpLogid", "")
            # print("otp_check_id",otp_check_id)
            # if not otp_check_id:
            #     flash("Invalid Request.")
            #     return render_template("super_admin_templates/api_setup_charge_commissions_table_list.html")

            # otpcheck_queryset = OtpChecks.objects(adminId=adminId, id=str(otp_check_id), status=1).first()

            # if not otpcheck_queryset:
            #     flash("Invalid Request.")
            #     return render_template("super_admin_templates/api_setup_charge_commissions_table_list.html")
            # # Update OTP status to 2 after verification
            # otpcheck_queryset.update(status=2)


            
            search_action = request.args.get("action")

            ######################## Common Lists ###########################
            # transaction_API_queryset = TransactionAPI.objects(status__in=[0, 1]).order_by('-id').all()
            # for each_transaction_api in transaction_API_queryset:
            #     service_grouping_dict = {
            #         "id": str(each_transaction_api.id),
            #         "apiName": each_transaction_api.apiName
            #     }
            #     transactionAPIsList.append(service_grouping_dict)


            payments_mod_queryset = PaymentMode.objects(status__in=[0, 1]).order_by("-id").all()
            for each_payment_mode in payments_mod_queryset:
                paymentsModeList.append(fetching_payment_mode_details(each_payment_mode))

         
            
            if request.method == "GET" and request.args.get("action") == "search":
                if form.validate():
                    paymentModeId = request.args.get("paymentModeId")
                    subPaymentModeId = request.args.get("subPaymentModeId")
                    servicePaymentType = request.args.get("servicePaymentType")
                    # holidayPrice = request.args.get("holidayPrice")
                    editable = True
                    update = True

                    payments_mod_queryset1 = PaymentMode.objects(id=paymentModeId,status__in=[0, 1]).first()

                    # txn_queryset = TransactionAPI.objects(id=transactionAPIId,status__in=[0, 1]).first()

                    paymentModeName = payments_mod_queryset1.paymentMode
                    # txnName = txn_queryset.apiName

                    # print(paymentModeName,"(((((((((paymentModeName)))))))))")
                    # print(txnName,"(((((((((txnName)))))))))")
                    # print(holidayPrice,"(((((((((holidayPrice)))))))))")

                    # if holidayPrice == "True":
                    #     holidayPrice=True
                    # else:
                    #     holidayPrice=False
                    
                    # print(paymentModeId,"(((((((((paymentModeId)))))))))")
                    # print(subPaymentModeId,"(((((((((subPaymentModeId)))))))))")
                    # print(transactionAPIId,"(((((((((transactionAPIId)))))))))")

                    # Search for matching records
                    
                    # transaction_queryset = TransactionAPI.objects(id=str(transactionAPIId)).first()
                    # if transaction_queryset:
                    #     transactionapiName=transaction_queryset.apiName

                    sub_payments_mod_queryset = SubPaymentModes.objects(paymentModeId=paymentModeId,status__in=[0, 1]).order_by("priority").all()
                    for each_sub_payment_mode in sub_payments_mod_queryset:
                        setup_charge_commission_queryset = ServicePaymentSetupChargeCommission.objects(subPaymentModeIdsList__in=[str(each_sub_payment_mode.id)],
                        paymentModeIdsList__in=[paymentModeId],
                        servicePaymentType=servicePaymentType,
                        # transactionAPIIdsList__in=[transactionAPIId],
                        # holidayPrice=holidayPrice,
                        status=1).first()
                        if setup_charge_commission_queryset:
                            finalPrice=0
                            price_ranges=[]
                            if setup_charge_commission_queryset.priceType == 'RANGE':
                                price_ranges = setup_charge_commission_queryset.priceRangeList

                            finalPrice=float(setup_charge_commission_queryset.chargeValue)
                            if setup_charge_commission_queryset.gstInclude=="No":
                                finalPrice=float(finalPrice)+float(setup_charge_commission_queryset.chargeValue)*float(setup_charge_commission_queryset.gstValue)/100
                            if setup_charge_commission_queryset.tdsInclude=="No":
                                finalPrice=float(finalPrice)+float(setup_charge_commission_queryset.chargeValue)*float(setup_charge_commission_queryset.tdsValue)/100

                            setup_charge_commission_dict= {
                                "id":str(each_sub_payment_mode.id),
                                "servicePaymentType":servicePaymentType,
                                "subPaymentModeType": each_sub_payment_mode.subPaymentModeType,  # Use the subPaymentModeType
                                "subPaymentModeId": str(each_sub_payment_mode.id),  # Keep the ID for reference
                                "priceType": setup_charge_commission_queryset.priceType,
                                "chargeType": setup_charge_commission_queryset.chargeType,
                                "chargeValue": setup_charge_commission_queryset.chargeValue,
                                "gstInclude": setup_charge_commission_queryset.gstInclude,
                                "gstValue": setup_charge_commission_queryset.gstValue,
                                "tdsInclude": setup_charge_commission_queryset.tdsInclude,
                                "tdsValue": setup_charge_commission_queryset.tdsValue,
                                "finalPrice": round(finalPrice,2),
                                "price_ranges": price_ranges
                            }
                        else:
                            setup_charge_commission_dict= {
                                "id":str(each_sub_payment_mode.id),
                                "servicePaymentType":servicePaymentType,
                                "subPaymentModeType": str(each_sub_payment_mode.subPaymentModeType),
                                "subPaymentModeId": str(each_sub_payment_mode.id),
                                "priceType": "",
                                "chargeType": "",
                                "chargeValue": 0,
                                "gstInclude": "",
                                "gstValue": 0,
                                "tdsInclude": "",
                                "tdsValue": 0,
                                "finalPrice": 0,
                                "price_ranges": []
                            }

                        # print("_____dict value",setup_charge_commission_dict)

                        setup_charge_commission_list.append(setup_charge_commission_dict)
                    if len(setup_charge_commission_list) > 0:
                        showData=True
                    return render_template(
                        "super_admin_templates/service_payment_setup_table.html",
                        paymentModeId=paymentModeId,
                        paymentsModeList=paymentsModeList,
                        servicePaymentType=servicePaymentType,
                        # transactionapiName=transactionapiName,
                        # transactionAPIsList=transactionAPIsList,
                        setup_charge_commission=setup_charge_commission,
                        subPaymentsModeList=subPaymentsModeList,
                        setup_charge_commission_list=setup_charge_commission_list,
                        # holidayPrice=holidayPrice,
                        # priceRangeList=price_ranges,
                        editable=editable,
                        showData=showData,
                        paymentModeName=paymentModeName,
                        # txnName=txnName,
                        update= update,
                        form=form
                    )
                print(form.errors,"((((((form errors ))))))")

            return render_template("super_admin_templates/service_payment_setup_table.html",
                commissionsList=commissionsList,
                subPaymentsModeList=subPaymentsModeList,
                setup_charge_commission=setup_charge_commission,
                paymentsModeList=paymentsModeList,
                servicePaymentType=servicePaymentType,
                # transactionAPIsList=transactionAPIsList,
                redirectval=redirectTo,
                error=error,
                editable=editable,
                showData=showData,
                paymentModeName=paymentModeName,
                # txnName=txnName,
                success_message=success_message,
                form=form
            )

        except Exception as e:
            app.logger.error(traceback.format_exc())
            error = "Unable to fetch setup charge commission details!!"
            flash(error, "error")
            return render_template("super_admin_templates/service_payment_setup_table.html",commissionsList=commissionsList,
                subPaymentsModeList=subPaymentsModeList,
                setup_charge_commission=setup_charge_commission,
                paymentsModeList=paymentsModeList,
                servicePaymentType=servicePaymentType,
                # transactionapiName=transactionapiName,
                redirectval=redirectTo,
                error=error,
                editable=editable,
                paymentModeName=paymentModeName,
                # txnName=txnName,
                showData=showData,
                success_message=success_message,
                form=form
                )
    else:
        flash("The staff member does not have permission to view Service payment setup charge commission table list.", "danger")
        return redirect(url_for("admin.dashboard"))


@patterns_configuarations.route("/payment_upsert_setup_charge_commission_table", methods=["POST"])
@adminid_access_token_required
@csrf_protect
def payment_upsert_setup_charge_commission_table():
    data_status={"responseStatus": 0, "result": 0}
    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()

    try:
        print(request.form,"request.form")
        paymentModeId = request.form.get("paymentModeId", "")
        subPaymentModeIdList = request.form.getlist("subPaymentModeId[]")
        servicePaymentType = request.form.get("servicePaymentType", "")
        priceType = request.form.get("priceType", "FIXED")
        gstIncludeList = request.form.getlist("gstInclude[]")
        gstValueList = request.form.getlist("gstValue[]")
        tdsIncludeList = request.form.getlist("tdsInclude[]")
        tdsValueList = request.form.getlist("tdsValue[]")
        chargeTypeList = request.form.getlist("chargeType[]")
        chargeValueList = request.form.getlist("chargeValue[]")
        # holidayPrice = request.form.get("holidayPrice",False)
        price_range_list = []
        priceDict={}

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

        is_valid, error_list = validate_api_setup_charges_table(
            gstIncludeList=gstIncludeList,
            gstValueList=gstValueList,
            tdsIncludeList=tdsIncludeList,
            tdsValueList=tdsValueList,
            chargeTypeList=chargeTypeList,            
            chargeValueList=chargeValueList
            )

        if is_valid:

            # print("(((((holidayPrice)))))",holidayPrice)
            # print("(((((holidayPrice)))))",type(holidayPrice))
            # if holidayPrice == "True":
            #     holidayPrice=True
            # else:
            #     holidayPrice=False
            # print("(((((holidayPrice after)))))",holidayPrice)
            for i in range(len(subPaymentModeIdList)):

                gstInclude = gstIncludeList[i]
                gstValue = float(gstValueList[i]) if gstValueList[i] else 0
                tdsInclude = tdsIncludeList[i]
                tdsValue = float(tdsValueList[i]) if tdsValueList[i] else 0
                chargeType = chargeTypeList[i]
                chargeValue = float(""+chargeValueList[i]) if chargeValueList[i] else 0
                subPaymentModeId= subPaymentModeIdList[i]
                # print(paymentModeId,"paymentModeId")
                # print(subPaymentModeId,"subPaymentModeId")
                # print(priceType,"priceType")

                # if gstValue and not is_valid_txn_limit(gstValue):
                #     flash("Please enter a valid Gst Value")
                #     return redirect(url_for("patterns_configuarations.get_api_setup_charge_commissions_table_list"))

                # if tdsValue and not is_valid_txn_limit(tdsValue):
                #     flash("Please enter a valid Tds Value")
                #     return redirect(url_for("patterns_configuarations.get_api_setup_charge_commissions_table_list"))

                # if chargeValue and not is_valid_txn_limit(chargeValue):
                #     flash("Please enter a valid Charge Value")
                #     return redirect(url_for("patterns_configuarations.get_api_setup_charge_commissions_table_list"))
                
                existing_record = ServicePaymentSetupChargeCommission.objects(paymentModeIdsList__in=[paymentModeId],
                    subPaymentModeIdsList__in=[subPaymentModeId],servicePaymentType=servicePaymentType,status=1).first()
                if existing_record:
                    existing_record.update(priceType=priceType,chargeType=chargeType,chargeValue=float(chargeValue),priceRangeList=price_range_list,gstInclude=gstInclude,gstValue=float(gstValue),tdsInclude=tdsInclude,tdsValue=float(tdsValue))
                    # flash("updated successfully!", "success")
                else:
                    admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
                    if admin_queryset:
                        message=admin_queryset.userName+" Service payment Setup charge commission table list Updated successfully!"
                        save_admin_log_table = save_admin_logs_data(adminId,None,None,"payment_upsert_setup_charge_commission_table","create",actionDate,client_ip,browser,message,requestData,updatedrequestData,latitude,longitude) 
                    # print("is new record++++++++++++++++++++")
                    new_record = ServicePaymentSetupChargeCommission(
                        adminId=session.get("adminId"),
                        paymentModeIdsList=[ObjectId(paymentModeId)],
                        # transactionAPIIdsList=[ObjectId(transactionAPIId)],
                        subPaymentModeIdsList=[ObjectId(subPaymentModeId)],
                        priceType=priceType,
                        gstInclude=gstInclude,
                        gstValue=float(gstValue),
                        tdsInclude=tdsInclude,
                        tdsValue=float(tdsValue),
                        chargeType=chargeType,
                        chargeValue=float(chargeValue),
                        priceRangeList=price_range_list,
                        servicePaymentType=servicePaymentType,
                        createdOn=datetime.datetime.now(),
                        status=1,
                        # holidayPrice=holidayPrice,
                    )
                    new_record.save()
            flash("Setup charge commission Details Updated successfully!", "success")
            data_status["responseStatus"]=1
            return data_status
            print("BBBBBJBB((((((((((((((((((((((((((((((((((((((((()))))))))))))))))))))))))))))))))))))))))")
        else:
            print("form errors",error_list)
            data_status["responseStatus"]=0
            data_status["result"]=error_list
            return data_status
    except Exception as e:
        app.logger.error(traceback.format_exc())
        flash(f"Error in upserting record: {str(e)}", "error")
        data_status["responseStatus"]=4
        return data_status

