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

@user.route("/login", methods=["POST", "GET"])
def login():
	data_status = {"responseStatus": 0, "result": ""}
	if request.method == "GET":
		return render_template("grievance/department/admin_login.html")

	elif request.method == "POST":
		email = request.form.get("email", "")
		password = request.form.get("password", "")

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

							session["departmentId"] = str(admin_queryset.id)
							session["name"] = admin_queryset.userName
							session["imageString"] = imageString
							return redirect(url_for("user.dashboard"))
						else:
							error = "Inactive account!"
							return render_template("grievance/department/admin_login.html", error=error)
					else:
						error = "Wrong password!"
						return render_template("grievance/department/admin_login.html", error=error)
				else:
					error = "Invalid email id!"
					return render_template("grievance/department/admin_login.html", error=error)
			except Exception as e:
				app.logger.error(traceback.format_exc())
				return render_template("grievance/department/admin_login.html")
		else:
			error = "Required fields are missing!!"
			return render_template("grievance/department/admin_login.html", error=error)


@user.route("/dashboard",methods=["POST","GET"])
# @token_required
def dashboard():
	try:
		if not session.get("departmentId"):
			return redirect("login")
		departmentId = session.get("departmentId")
		adminDict = {}
		admin_queryset = GrievanceDepartmentUsers.objects(id=departmentId,status__in=[1]).first()
		departmentIdList = [str(each_record.id) for each_record in admin_queryset.departmentIdList]
		grievance_count = Grievances.objects(departmentId__in=departmentIdList).all()
		grievanceCount=grievance_count.filter().count()
		grievancePendingCount=grievance_count.filter(status=0).count()
		grievanceAcceptedCount=grievance_count.filter(status=1).count()
		grievanceRejectedCount=grievance_count.filter(status=2).count()
		adminDict = {
		"name":admin_queryset.userName,
		"grievanceCount":grievanceCount,
		"grievancePendingCount":grievancePendingCount,
		"grievanceAcceptedCount":grievanceAcceptedCount,
		"grievanceRejectedCount":grievanceRejectedCount
		}
		return render_template(
			"grievance/department/dashboard.html",
			adminDict=adminDict,
			)
	except Exception as e:
		app.logger.error(traceback.format_exc())
		return redirect(url_for('user.login'))

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

		departmentId = session.get("departmentId")
		
		admin_queryset = GrievanceDepartmentUsers.objects(id=departmentId).first()

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

def fetch_admin_details(admin_queryset):
	loginDict={}
	try:
		loginDict={
		"id":str(admin_queryset.id),
		"name":admin_queryset.userName,
		"email":admin_queryset.email,
		"mobileNumber":admin_queryset.mobileNumber,
		"createdOn":admin_queryset.createdOn.astimezone(tzinfo),
		"status":admin_queryset.status
		}
	except Exception as e:
		app.logger.error(traceback.format_exc())
	return loginDict

@user.route("/admin_change_password", methods=["POST", "GET"])
def admin_change_password():
	if not session.get("departmentId"):
		return redirect(url_for("user.login"))
	departmentId = session.get("departmentId")
	loginBrowser = request.headers.get("Sec-Ch-Ua")
	userAgent = request.headers.get("User-Agent")
	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()
	existing_record = ""
	requestData = []
	
	if request.method == "GET":
		print("GET request received.")
		try:
			admin_queryset = GrievanceDepartmentUsers.objects(id=departmentId).first()
			existing_record = admin_queryset.to_json()
			updatedrequestData = [existing_record]
			save_admin_log_table = save_admin_logs_data(departmentId,None,None,"login","login",actionDate,client_ip,browser,"",requestData,updatedrequestData)
			message=admin_queryset.userName+" Successfully changed the password!"
			save_admin_log_table.update(message=message)

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

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

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

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

		try:
			admin_queryset = GrievanceDepartmentUsers.objects(id=departmentId).first()
			if not admin_queryset:
				flash("Invalid admin id!")
				return redirect(url_for("user.login"))

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

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




def fetching_department_grievances(grievances_queryset):
    grievances_dict = {}
    try:
        grievances_dict={
        "id":str(grievances_queryset.id),
        "customerName":grievances_queryset.name,
        "customerMobileNumber":grievances_queryset.mobileNumber, 
        }

        try:
            if grievances_queryset.userId:
                grievances_dict["userId"]=str(grievances_queryset.userId.id)
                grievances_dict["fullName"]=grievances_queryset.userId.fullName
            else:
                grievances_dict["userId"]=""
                grievances_dict["fullName"]=""
        except Exception as e:
            grievances_dict["userId"]=""
            grievances_dict["fullName"]=""

        try:
            if grievances_queryset.departmentId:
                grievances_dict["departmentId"]=str(grievances_queryset.departmentId.id)
                grievances_dict["departmentName"]=grievances_queryset.departmentId.departmentName
            else:
                grievances_dict["departmentId"]=""
                grievances_dict["departmentName"]=""
        except Exception as e:
            grievances_dict["departmentId"]=""
            grievances_dict["departmentName"]=""

        try:
            if grievances_queryset.assemblyMemberId:
                grievances_dict["assemblyMemberId"]=str(grievances_queryset.assemblyMemberId.id)
                grievances_dict["mlaName"]=grievances_queryset.assemblyMemberId.mlaName
            else:
                grievances_dict["assemblyMemberId"]=""
                grievances_dict["mlaName"]=""
        except Exception as e:
            grievances_dict["assemblyMemberId"]=""
            grievances_dict["mlaName"]=""

        try:
            if grievances_queryset.pincodeId:
                grievances_dict["pincodeId"]=str(grievances_queryset.pincodeId.id)
                grievances_dict["pincode"]=grievances_queryset.pincodeId.pincode
            else:
                grievances_dict["pincodeId"]=""
                grievances_dict["pincode"]=""
        except Exception as e:
            grievances_dict["pincodeId"]=""
            grievances_dict["pincode"]=""

        try:
            if grievances_queryset.pincodeId:
                grievances_dict["blockPoId"]=str(grievances_queryset.pincodeId.blockPoId.id)
                grievances_dict["blockName"]=grievances_queryset.pincodeId.blockPoId.name
            else:
                grievances_dict["blockPoId"]=""
                grievances_dict["blockName"]=""
        except Exception as e:
            grievances_dict["blockPoId"]=""
            grievances_dict["blockName"]=""

        try:
            if grievances_queryset.pincodeId:
                grievances_dict["cityId"]=str(grievances_queryset.pincodeId.blockPoId.cityId.id)
                grievances_dict["cityName"]=grievances_queryset.pincodeId.blockPoId.cityId.cityName
            else:
                grievances_dict["cityId"]=""
                grievances_dict["cityName"]=""
        except Exception as e:
            grievances_dict["cityId"]=""
            grievances_dict["cityName"]=""

        try:
            if grievances_queryset.pincodeId:
                grievances_dict["stateId"]=str(grievances_queryset.pincodeId.blockPoId.cityId.stateId.id)
                grievances_dict["stateName"]=grievances_queryset.pincodeId.blockPoId.cityId.stateId.stateName
            else:
                grievances_dict["stateId"]=""
                grievances_dict["stateName"]=""
        except Exception as e:
            grievances_dict["stateId"]=""
            grievances_dict["stateName"]=""

        try:
            if grievances_queryset.pincodeId:
                grievances_dict["countryId"]=str(grievances_queryset.pincodeId.blockPoId.cityId.stateId.countryId.id)
                grievances_dict["countryName"]=grievances_queryset.pincodeId.blockPoId.cityId.stateId.countryId.countryName
            else:
                grievances_dict["countryId"]=""
                grievances_dict["countryName"]=""
        except Exception as e:
            grievances_dict["countryId"]=""
            grievances_dict["countryName"]=""

        try:
            if grievances_queryset.pincodeId:
                grievances_dict["regionId"]=str(grievances_queryset.pincodeId.blockPoId.cityId.stateId.countryId.regionId.id)
                grievances_dict["regionName"]=grievances_queryset.pincodeId.blockPoId.cityId.stateId.countryId.regionId.regionName
            else:
                grievances_dict["regionId"]=""
                grievances_dict["regionName"]=""
        except Exception as e:
            grievances_dict["regionId"]=""
            grievances_dict["regionName"]=""
        
        if grievances_queryset.status==1:
            grievances_dict["actionText"] = "Accepted"
        elif grievances_queryset.status==2:
            grievances_dict["actionText"] = "Rejected"
        else:
            grievances_dict["actionText"] = "Pending"

        

        if grievances_queryset.createdOn:
            grievances_dict["createdOn"] = grievances_queryset.createdOn.strftime("%d-%m-%Y")
        else:
            grievances_dict["createdOn"] = ""

        

    except Exception as e:
        app.logger.error(traceback.format_exc())
    return grievances_dict


@user.route("/department_users_grievances_list", methods=["POST", "GET"])
def department_users_grievances_list():
    if not session.get("departmentId"):
        return redirect("login")

    grievancesList = []
    usersList = []
    departmentsList = []
    pincodeList = []
    reqdepartmentIdList = []
    # assemblyList = []
    grievancesPagination = ""

    departmentId = session.get("departmentId")
   
    try:
        redirectTo = request.args.get("redirectTo", "grievances")
        redirectval = redirectTo if redirectTo else "grievances"
       
        grivance_department_users_queryset = GrievanceDepartmentUsers.objects(id=departmentId).first()
        departmentIdList = [str(each_record.id) for each_record in grivance_department_users_queryset.departmentIdList]
       
        requestDepartmentId = request.args.get("departmentId","")
        if requestDepartmentId:
        	reqdepartmentIdList = [str(requestDepartmentId)]
        else:
        	reqdepartmentIdList=departmentIdList

        
        print(departmentId,"((((((((((departmentId))))))))))")
        grievances_queryset = Grievances.objects(departmentId__in=reqdepartmentIdList,status__in=[0, 1,2]).order_by("-sorting")
        
        grievancesPage = request.args.get(get_page_parameter('grievancesPage'), type=int, default=1)
        per_page = 20
        total_count = grievances_queryset.count()
        start = (grievancesPage - 1) * per_page
        end = min(start + per_page, total_count)

        total_grievances = grievances_queryset[start:end]
       
        snoCount = start
        for each_grievance in total_grievances:
            snoCount += 1
            grievances_dict = fetching_department_grievances(each_grievance)
            grievances_dict["snoCount"] = snoCount
            grievancesList.append(grievances_dict)

        grievancesPagination = Pagination(grievancesPage=grievancesPage, total=total_count, page_parameter="grievancesPage", per_page=per_page, alignment="right", record_name="grievances")
        
        departments_queryset = Departments.objects(id__in=departmentIdList,status__in=[0, 1]).order_by('sorting')
        for each_department in departments_queryset:
            departments_dict = fetching_departments(each_department)
            departmentsList.append(departments_dict)

   
        return render_template("grievance/department/department_grievances_list.html",
            grievancesPagination=grievancesPagination,
            grievancesList=grievancesList,
            departmentsList=departmentsList,
            redirectval=redirectval,
        )
    except Exception as e:
        app.logger.error(traceback.format_exc())
        error = "Unable to fetch grievances !!"
        return render_template("grievance/department/department_grievances_list.html",
            grievancesPagination=grievancesPagination,
            grievancesList=grievancesList,
            departmentsList=departmentsList,
            redirectval=redirectval,
        )


@user.route("/update_grievance", methods=["POST","GET"])
def update_grievance():
    if not session.get("departmentId"):
        flash("Unauthorized access", "danger")
        return redirect(url_for("user.department_users_grievances_list"))

    grievance_id = request.args.get("grievanceId")
    print(grievance_id,"(((((((((((grievance_id)))))))))))")
    new_status = request.args.get("status")

    app.logger.debug(f"Form submitted with grievanceId={grievance_id}, status={new_status}")

    if not grievance_id or new_status not in ["0", "1", "2"]:
        flash("Invalid grievance update request", "danger")
        return redirect(url_for("user.department_users_grievances_list"))

    try:
        # Use `.first()` to safely fetch the grievance
        grievance = Grievances.objects(id=grievance_id).first()
        if not grievance:
            flash("Grievance not found", "danger")
            return redirect(url_for("user.department_users_grievances_list"))

        # Update and save grievance status
        grievance.status = int(new_status)
        grievance.save()

        app.logger.debug(f"Updated grievance {grievance_id} with status {new_status}")
        flash("Grievance status updated successfully", "success")
        return redirect(url_for("user.department_users_grievances_list"))
    except Exception as e:
        app.logger.error(f"Error updating grievance status: {e}")
        flash("Failed to update grievance status", "danger")
        return redirect(url_for("user.department_users_grievances_list"))
