from appservices.common.util import *

transaction_limit_settings = Blueprint("transaction_limit_settings",__name__)

# Add Transaction Limit Setting
@transaction_limit_settings.route("/add_transaction_limit_setting",methods=["POST","GET"])
def add_transaction_limit_setting():
	try:
		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 = userAgent.split(";")
			browser = loginBrowseData[0]

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

		actionDate=datetime.datetime.now()
		
		if request.method == "POST":
			name = request.form.get("name","")
			code = request.form.get("code","")
			pgType = request.form.get("pgType","")
			singleTxnLowerLimit = request.form.get("singleTxnLowerLimit","")
			singleTxnUpperLimit = request.form.get("singleTxnUpperLimit","")
			dailyTxnLimit = request.form.get("dailyTxnLimit","")
			dailyTxnCount = request.form.get("dailyTxnCount","")
			minimunAccountBalance = request.form.get("minimunAccountBalance","")
			monthlyTxnLimit = request.form.get("monthlyTxnLimit","")
			monthlyTxnCount = request.form.get("monthlyTxnCount","")
			isUserWise = request.form.get("isUserWise")
			# userId = request.form.get("userId","")
			paymentGatewayIds = request.form.getlist("paymentGatewayIds")
			userIds = request.form.getlist("userIds")

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

			if name and code and paymentGatewayIds and singleTxnLowerLimit and singleTxnUpperLimit and dailyTxnLimit and dailyTxnCount and minimunAccountBalance and monthlyTxnLimit and monthlyTxnCount:
				try:
					admin_queryset = SuperAdmin.objects(id=adminId,status=1).first()
					if admin_queryset:
						message=admin_queryset.userName+" "+name+" Transaction limit setting created successfully!"
						save_admin_log_table = save_admin_logs_data(adminId,None,None,"add_transaction_limit_setting","create",actionDate,client_ip,browser,message,requestData,updatedrequestData)

					if isUserWise == None:
						isUserWise=False
						userIds=[]
					else:
						isUserWise=True
						userIds=userIds

					transaction_limit_table = TransactionLimitSettings(
						adminId = adminId,
						name = name,
						code = code,
						pgType = pgType,
						isUserWise = isUserWise,
						userIds = userIds,
						paymentGatewayIds = paymentGatewayIds,
						singleTxnLowerLimit = singleTxnLowerLimit,
						singleTxnUpperLimit = singleTxnUpperLimit,
						dailyTxnLimit = dailyTxnLimit,
						dailyTxnCount = dailyTxnCount,
						minimunAccountBalance = minimunAccountBalance,
						monthlyTxnLimit = monthlyTxnLimit,
						monthlyTxnCount = monthlyTxnCount,
						createdOn = datetime.datetime.now(),
						status = 1,
						)
					save_table = transaction_limit_table.save()
					txnLimitSettingId = str(save_table.id)

					flash("Transaction limit setting saved successfully!")
					return redirect(url_for("transaction_limit_settings.txn_limit_settings_list"))
				except Exception as e:
					flash("Unable to save transaction limit setting!!")
					app.logger.error(traceback.format_exc())
					return redirect(url_for("transaction_limit_settings.txn_limit_settings_list"))
			else:
				flash("Required fields are missing!!")
				return redirect(url_for("transaction_limit_settings.txn_limit_settings_list"))
	except Exception as e:
		app.logger.error(traceback.format_exc())
		error = "Unable to save fee distribution setting!!"
		return render_template("super_admin_templates/transaction_limit_settings.html",error=error)

def fetching_txn_limit_settings_details(txn_limit_setting_queryset):
	txn_limit_setting_dict = {}
	try:
		txn_limit_setting_dict={
		"id":str(txn_limit_setting_queryset.id),
		"name":txn_limit_setting_queryset.name,
		"code":txn_limit_setting_queryset.code,
		"pgType":txn_limit_setting_queryset.pgType,
		"singleTxnLowerLimit":txn_limit_setting_queryset.singleTxnLowerLimit,
		"singleTxnUpperLimit":txn_limit_setting_queryset.singleTxnUpperLimit,
		"dailyTxnLimit":txn_limit_setting_queryset.dailyTxnLimit,
		"dailyTxnCount":txn_limit_setting_queryset.dailyTxnCount,
		"minimunAccountBalance":txn_limit_setting_queryset.minimunAccountBalance,
		"monthlyTxnLimit":txn_limit_setting_queryset.monthlyTxnLimit,
		"monthlyTxnCount":txn_limit_setting_queryset.monthlyTxnCount,
		"isUserWise":txn_limit_setting_queryset.isUserWise,
		# "paymentGatewayId":str(txn_limit_setting_queryset.paymentGatewayId.id),
		# "apiName":txn_limit_setting_queryset.paymentGatewayId.apiName
		}
		# try:
		#     pgPayinList = []
		#     if txn_limit_setting_queryset.paymentGatewayIds:
		#         for each_payin_pg in txn_limit_setting_queryset.paymentGatewayIds:
		#             pgPayinDict = {
		#             "paymentGatewayId":str(each_payin_pg.id),
		#             "paymentGatewayName":each_payin_pg.apiName
		#             }
		#             pgPayinList.append(pgPayinDict)
		#         txn_limit_setting_dict["pgPayinList"]=pgPayinList
		#     else:
		#         txn_limit_setting_dict["pgPayinList"]=[]
		# except Exception as e:
		#     txn_limit_setting_dict["pgPayinList"]=[]

		if txn_limit_setting_queryset.paymentGatewayIds:
			txn_limit_setting_dict["paymentGatewayIds"]=[str(each_api.id) for each_api in txn_limit_setting_queryset.paymentGatewayIds]
			txn_limit_setting_dict["apiNamesList"]=[str(each_api.apiName) for each_api in txn_limit_setting_queryset.paymentGatewayIds]

			txn_limit_setting_dict["apiNames"] = ', '.join(txn_limit_setting_dict["apiNamesList"])
		else:
			txn_limit_setting_dict["paymentGatewayIds"]=[]
			txn_limit_setting_dict["apiNames"]=""

		if txn_limit_setting_queryset.userIds:
			txn_limit_setting_dict["userIds"]=[str(each_user.id) for each_user in txn_limit_setting_queryset.userIds]
			txn_limit_setting_dict["userNamesList"]=[str(each_user.fullName) for each_user in txn_limit_setting_queryset.userIds]

			txn_limit_setting_dict["userNames"] = ', '.join(txn_limit_setting_dict["userNamesList"])
		else:
			txn_limit_setting_dict["userIds"]=[]
			txn_limit_setting_dict["userNames"]=""

		# try:
		#     if txn_limit_setting_queryset.userId:
		#         txn_limit_setting_dict["userId"]=str(txn_limit_setting_queryset.userId.id)
		#         txn_limit_setting_dict["userName"]=txn_limit_setting_queryset.userId.fullName
		#     else:
		#         txn_limit_setting_dict["userId"]=""
		#         txn_limit_setting_dict["userName"]=""
		# except Exception as e:
		#     txn_limit_setting_dict["userId"]=""
		#     txn_limit_setting_dict["userName"]=""

		if txn_limit_setting_queryset.status==1:
			txn_limit_setting_dict["actionText"] = "Active"
		else:
			txn_limit_setting_dict["actionText"] = "Deactive"

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

# View All transaction limit settings
@transaction_limit_settings.route("/txn_limit_settings_list",methods=["POST","GET"])
def txn_limit_settings_list():
	if not session.get("adminId"):
		return redirect("admin_login")
	adminId = session.get("adminId")
	txnLimitSettingsList = []
	apiDropdownList =[]
	transaction_api_dict ={}
	userList =[]
	try:
		search_element = request.args.get('search_element','')
		
		page = request.args.get(get_page_parameter(), type=int, default=1)
		page_start,page_end=fetch_limit_length_based_on_page_index(page,20)
		pagination = Pagination(
			page=page,
			record_name='transaction_limit_settings',
			per_page=20,
			alignment="right"
			)
		txn_limit_settings_queryset = TransactionLimitSettings.objects(status__in=[0,1]).order_by("-id")
		if search_element:
			txn_limit_settings_queryset = txn_limit_settings_queryset.filter(Q(name__icontains=search_element))
		length = txn_limit_settings_queryset.count()
		txn_limit_settings_queryset=txn_limit_settings_queryset[page_start:page_end]

		for each_txn_limit_setting in txn_limit_settings_queryset:
			txn_limit_setting_dict = fetching_txn_limit_settings_details(each_txn_limit_setting)
			txnLimitSettingsList.append(txn_limit_setting_dict)

		users_queryset = Users.objects(status__in=[0,1]).order_by("-id")  
		for each_user in users_queryset:
			user_dict = fetching_user_details(each_user)
			userList.append(user_dict)


		pagination = Pagination(
			page=page,
			total=length,
			found=length,
			record_name='transaction_limit_settings',
			per_page=20,
			alignment="right"
			)
		return render_template("super_admin_templates/transaction_limit_settings.html",
			txnLimitSettingsList=txnLimitSettingsList,
			search_element=search_element,
			pagination=pagination,
			# apiDropdownList=apiDropdownList,
			userList=userList,
			)
	except Exception as e:
		app.logger.error(traceback.format_exc())
		error = "Unable to fetch transaction limit settings details!!"
		return render_template("super_admin_templates/transaction_limit_settings.html",
			txnLimitSettingsList=txnLimitSettingsList,
			search_element=search_element,
			pagination=pagination,
			# apiDropdownList=apiDropdownList,
			userList=userList,
			)



# Update transaction limit setting status
@transaction_limit_settings.route("/update_txn_limit_setting_status",methods=["POST","GET"])
def update_txn_limit_setting_status():
	if not session.get("adminId"):
		return redirect("admin_login")
	adminId=session.get("adminId")
	loginBrowser = request.headers.get("Sec-Ch-Ua")
	if loginBrowser:
		loginBrowseData = loginBrowser.split(";")
		browser = loginBrowseData[0]
	else:
		loginBrowseData = userAgent.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]
	txnLimitSettingId = request.args.get("txnLimitSettingId","")

	if txnLimitSettingId:
		try:
			txn_limit_setting_queryset = TransactionLimitSettings.objects(id=txnLimitSettingId,status__nin=[2]).first()
			existing_record = txn_limit_setting_queryset.to_json()
			requestData = [existing_record]
			if txn_limit_setting_queryset:
				if txn_limit_setting_queryset.status == 0:
					txn_limit_setting_queryset.update(status=1)
					flash("Transaction limit setting activated successfully!")
					message=txn_limit_setting_queryset.adminId.userName+" "+txn_limit_setting_queryset.name+" Transaction limit setting activated successfully!"
				elif txn_limit_setting_queryset.status == 1:
					txn_limit_setting_queryset.update(status=0)
					flash("Transaction limit setting deactivated successfully!")
					message=txn_limit_setting_queryset.adminId.userName+" "+txn_limit_setting_queryset.name+" Transaction limit setting deactivated successfully!"
				save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_txn_limit_setting_status","updatestatus",actionDate,client_ip,browser,message,requestData,updatedrequestData)
				return redirect(url_for("transaction_limit_settings.txn_limit_settings_list"))
			else:
				flash("Invaild id!!")
				return redirect(url_for("transaction_limit_settings.txn_limit_settings_list"))
		except Exception as e:
			app.logger.error(traceback.format_exc())
			return redirect(url_for("transaction_limit_settings.txn_limit_settings_list"))
	else:
		return redirect(url_for("transaction_limit_settings.txn_limit_settings_list"))


# Delete transaction limit setting
@transaction_limit_settings.route("/delete_txn_limit_setting",methods=["GET"])
def delete_txn_limit_setting():
	try:
		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 = userAgent.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]

		if request.method == "GET":
			txnLimitSettingId = request.args.get("txnLimitSettingId","")
			txn_limit_setting_queryset = TransactionLimitSettings.objects(id=txnLimitSettingId,status__in=[0,1]).first()
			existing_record = txn_limit_setting_queryset.to_json()
			requestData = [existing_record]
			txn_limit_setting_queryset.update(status=2)
			flash("Transaction limit setting deleted successfully!")
			message=txn_limit_setting_queryset.adminId.userName+" "+txn_limit_setting_queryset.name+" Transaction limit setting deleted successfully!"
			save_admin_log_table = save_admin_logs_data(adminId,None,None,"delete_txn_limit_setting","delete",actionDate,client_ip,browser,message,requestData,updatedrequestData)
			return redirect(url_for("transaction_limit_settings.txn_limit_settings_list"))
	except Exception as e:
		app.logger.error(traceback.format_exc())
		flash("Unable to delete transaction limit setting!!")
		return redirect(url_for("transaction_limit_settings.txn_limit_settings_list"))




# Update transaction limit setting
@transaction_limit_settings.route("/update_txn_limit_setting",methods=["POST","GET"])
def update_txn_limit_setting():
	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 = userAgent.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()
	try:
		txnLimitSettingId = request.args.get("txnLimitSettingId","")
		if not txnLimitSettingId and not paymentGatewayIds:
			flash("Required fields are missing !!")
			return redirect(url_for("transaction_limit_settings.txn_limit_settings_list"))
		if request.method == "POST":
			name = request.form.get("name","")
			code = request.form.get("code","")
			pgType = request.form.get("pgType","")
			singleTxnLowerLimit = request.form.get("singleTxnLowerLimit","")
			singleTxnUpperLimit = request.form.get("singleTxnUpperLimit","")
			dailyTxnLimit = request.form.get("dailyTxnLimit","")
			dailyTxnCount = request.form.get("dailyTxnCount","")
			minimunAccountBalance = request.form.get("minimunAccountBalance","")
			monthlyTxnLimit = request.form.get("monthlyTxnLimit","")
			monthlyTxnCount = request.form.get("monthlyTxnCount","")
			isUserWise = request.form.get("isUserWise")
			paymentGatewayIds = request.form.getlist("paymentGatewayIds")
			userIds = request.form.getlist("userIds")
			jsonData = request.form.to_dict(flat=True)

			txn_limit_setting_queryset = TransactionLimitSettings.objects(id=txnLimitSettingId).first()
			existing_record = txn_limit_setting_queryset.to_json()
			message=txn_limit_setting_queryset.adminId.userName+" "+name+" transaction limit settings updated successfully!"
			requestData=[existing_record]
			updatedrequestData=[jsonData]
			save_admin_log_table = save_admin_logs_data(adminId,None,None,"update_txn_limit_setting","update",actionDate,client_ip,browser,message,requestData,updatedrequestData)

			if isUserWise == None:
				updateIsUserWise=False
				updateUserIds=[]
			else:
				updateIsUserWise=True
				updateUserIds=[ObjectId(eachUser) for eachUser in userIds]

			if paymentGatewayIds:
				updatePaymentGatewayIds=[ObjectId(eachPayinPg) for eachPayinPg in paymentGatewayIds]
			else:
				updatePaymentGatewayIds=[]

			if txn_limit_setting_queryset:
				txn_limit_setting_queryset.update(
					name=name,
					code=code,
					pgType=pgType,
					singleTxnLowerLimit=singleTxnLowerLimit,
					singleTxnUpperLimit=singleTxnUpperLimit,
					dailyTxnLimit=dailyTxnLimit,
					dailyTxnCount=dailyTxnCount,
					minimunAccountBalance=minimunAccountBalance,
					monthlyTxnLimit=monthlyTxnLimit,
					monthlyTxnCount=monthlyTxnCount,
					isUserWise=updateIsUserWise,
					userIds=updateUserIds,
					paymentGatewayIds=updatePaymentGatewayIds,
					)
				flash("transaction limit settings updated successfully!")
				return redirect(url_for("transaction_limit_settings.txn_limit_settings_list"))
			else:
				flash("Invaild id!!")
				return redirect(url_for("transaction_limit_settings.txn_limit_settings_list"))
	except Exception as e:
		app.logger.error(traceback.format_exc())
		error = "Unable to update category!!"
		return redirect(url_for("transaction_limit_settings.txn_limit_settings_list"))


@transaction_limit_settings.route("/pgtype_based_payment_gateways",methods=["POST"])
def pgtype_based_payment_gateways():
	data_status = {"responseStatus":0,"result":""}
	apiDropdownList =[]
	try:
		pgType = request.form.get("pgType","")
		
		if pgType == "Payin":
			transactionType = "PaymentGateway"
		else:
			transactionType = "Payout"

		transaction_API_queryset = TransactionAPI.objects(transactionType=transactionType,status=1).order_by('-id')
		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
			}
			apiDropdownList.append(transactionapiDict)

		data_status["responseStatus"]=1
		data_status["result"]="Payment Gateways fetched successfully"
		data_status["apiDropdownList"]=apiDropdownList
		return data_status
	except Exception as e:
		app.logger.error(traceback.format_exc())
		data_status["result"]="Unable to fetch payment gateways data!!"
		return data_status