from appservices.common.util import *

countries = Blueprint("countries",__name__)

csrf.exempt(countries)

def fetching_countries_details(country_queryset):
	country_dict = {}
	try:
		country_dict={
		"id":str(country_queryset.id),
		"countryName":country_queryset.countryName,
		"regex":country_queryset.regex,
		"regionName":country_queryset.regionId.regionName,
		"countryCode":country_queryset.countryCode
		}
		if country_queryset.createdOn:
			country_dict["createdOn"] = country_queryset.createdOn.strftime("%m-%d-%Y")
		else:
			country_dict["createdOn"] = ""

		if country_queryset.countryFlag:
			country_dict["countryFlag"] = domain+country_queryset.countryFlag
		else:
			country_dict["countryFlag"] = ""
	except Exception as e:
		app.logger.error(traceback.format_exc())
	return country_dict


@countries.route("/countries_list",methods=["POST"])
@encrypt_decrypt_before_login
def countries_list():
	data_status = {"responseStatus":0,"result":""}
	countriesList = []
	try:
		################# For Countries Data ##################
		countries_queryset = Countries.objects(status=1).order_by("-id").all()
		for each_country in countries_queryset:
			country_dict = fetching_countries_details(each_country)
			countriesList.append(country_dict)

		data_status["responseStatus"]=1
		data_status["result"]="Countries data fetched successfully!"
		data_status["countriesList"]=countriesList
		return data_status   
	except Exception as e:
		app.logger.error(traceback.format_exc())
		data_status["result"]="Unable to fetch countries data!!"
		return data_status

def fetching_states_details(state_queryset):
	state_dict = {}
	try:
		state_dict={
		"id":str(state_queryset.id),
		"stateName":state_queryset.stateName,
		"countryId":str(state_queryset.countryId.id),
		"countryName":state_queryset.countryId.countryName
		}
		if state_queryset.createdOn:
			state_dict["createdOn"] = state_queryset.createdOn.strftime("%m-%d-%Y")
		else:
			state_dict["createdOn"] = ""
	except Exception as e:
		app.logger.error(traceback.format_exc())
	return state_dict

@countries.route("/states_list",methods=["POST"])
@encrypt_decrypt_before_login
def states_list():
	data_status = {"responseStatus":0,"result":""}
	statesList = []
	try:
		data = request.decrypted_data
		countryId = data.get("countryId","")
		if not countryId:
			data_status["result"]="Required fields are missing!!"
			return data_status
		################# For States Data ##################
		states_queryset = States.objects(countryId=countryId,status__in=[0,1]).order_by("-id")
		for each_state in states_queryset:
			state_dict = fetching_states_details(each_state)
			statesList.append(state_dict)

		data_status["responseStatus"]=1
		data_status["result"]="States data fetched successfully!"
		data_status["statesList"]=statesList
		return data_status   
	except Exception as e:
		app.logger.error(traceback.format_exc())
		data_status["result"]="Unable to fetch states data!!"
		return data_status

def fetching_cities_details(city_queryset):
	city_dict = {}
	try:
		city_dict={
		"id":str(city_queryset.id),
		"cityName":city_queryset.cityName,
		"stateName":city_queryset.stateId.stateName,
		"stateId":str(city_queryset.stateId.id)
		}
		if city_queryset.createdOn:
			city_dict["createdOn"] = city_queryset.createdOn.strftime("%m-%d-%Y")
		else:
			city_dict["createdOn"] = ""
	except Exception as e:
		app.logger.error(traceback.format_exc())
	return city_dict


@countries.route("/cities_list",methods=["POST"])
@encrypt_decrypt_before_login
def cities_list():
	data_status = {"responseStatus":0,"result":""}
	citiesList = []
	try:
		data = request.decrypted_data
		stateId = data.get("stateId","")
		if not stateId:
			data_status["result"]="Required fields are missing!!"
			return data_status
		################# For Cities Data ##################
		cities_queryset = Cities.objects(stateId=stateId,status__in=[0,1]).order_by("-id")
		for each_city in cities_queryset:
			city_dict = fetching_cities_details(each_city)
			citiesList.append(city_dict)

		data_status["responseStatus"]=1
		data_status["result"]="Cities data fetched successfully!"
		data_status["citiesList"]=citiesList
		return data_status   
	except Exception as e:
		app.logger.error(traceback.format_exc())
		data_status["result"]="Unable to fetch cities data!!"
		return data_status


def fetching_user_type_details(user_type_queryset):
	userTypeDict = {}
	try:
		userTypeDict={
		"id":str(user_type_queryset.id),
		"userType":user_type_queryset.userType,
		"code":user_type_queryset.code,
		"description":user_type_queryset.description,
		"rank":user_type_queryset.rank,
		"isAllow":user_type_queryset.isAllow,
		"isCommission":user_type_queryset.isCommission,
		"isUser":user_type_queryset.isUser
		}
		if user_type_queryset.createdOn:
			userTypeDict["createdOn"] = user_type_queryset.createdOn.strftime("%m-%d-%Y")
		else:
			userTypeDict["createdOn"] = ""
	except Exception as e:
		app.logger.error(traceback.format_exc())
	return userTypeDict

@countries.route("/user_types_list",methods=["POST"])
@encrypt_decrypt_after_login
def user_types_list():
	data_status = {"responseStatus":0,"result":""}
	userTypesList = []
	try:
		user_types_queryset = UserTypes.objects(isUser=True,status=1).order_by("-id")

		for each_user_type in user_types_queryset:
			userTypeDict = fetching_user_type_details(each_user_type)
			userTypesList.append(userTypeDict)

		data_status["responseStatus"]=1
		data_status["result"]="User types data fetched successfully!"
		data_status["userTypesList"]=userTypesList
		return data_status   
	except Exception as e:
		app.logger.error(traceback.format_exc())
		data_status["result"]="Unable to fetch user types data!!"
		return 


def fetching_user_entity_details(user_entity_queryset):
	userEntityDict = {}
	try:
		userEntityDict={
		"id":str(user_entity_queryset.id),
		"entityType":user_entity_queryset.entityType
		}
	except Exception as e:
		app.logger.error(traceback.format_exc())
	return userEntityDict


@countries.route("/user_entity_list",methods=["POST"])
@encrypt_decrypt_after_login
def user_entity_list():
	data_status = {"responseStatus":0,"result":""}
	userEntityList = []
	try:
		user_entities_queryset = UserEntity.objects(status__in=[0,1]).order_by("-id")

		for each_user_entity in user_entities_queryset:
			userEntityDict = fetching_user_entity_details(each_user_entity)
			userEntityList.append(userEntityDict)

		data_status["responseStatus"]=1
		data_status["result"]="User entities data fetched successfully!"
		data_status["userEntityList"]=userEntityList
		return data_status   
	except Exception as e:
		app.logger.error(traceback.format_exc())
		data_status["result"]="Unable to fetch user entities data!!"
		return data_status

def fetching_blocks_details(block_queryset):
	block_dict = {}
	try:
		block_dict={
		"id":str(block_queryset.id),
		"name":block_queryset.name,
		"cityName":block_queryset.cityId.cityName,
		"cityId":str(block_queryset.cityId.id)
		}
		if block_queryset.createdOn:
			block_dict["createdOn"] = block_queryset.createdOn.strftime("%m-%d-%Y")
		else:
			block_dict["createdOn"] = ""
	except Exception as e:
		app.logger.error(traceback.format_exc())
	return block_dict

@countries.route("/block_po_list",methods=["POST"])
@encrypt_decrypt_before_login
def block_po_list():
	data_status = {"responseStatus":0,"result":""}
	blocksList = []
	try:
		data = request.decrypted_data
		cityId = data.get("cityId","")
		if not cityId:
			data_status["result"]="Required fields are missing!!"
			return data_status
		blocks_queryset = BlocksPos.objects(cityId=cityId,status=1).order_by("-id")
		for each_block in blocks_queryset:
			block_dict = fetching_blocks_details(each_block)
			blocksList.append(block_dict)

		data_status["responseStatus"]=1
		data_status["result"]="Blocks data fetched successfully!"
		data_status["blocksList"]=blocksList
		return data_status   
	except Exception as e:
		app.logger.error(traceback.format_exc())
		data_status["result"]="Unable to fetch blocks data!!"
		return data_status


def fetching_pincode_details(pincode_queryset):
	pincode_dict = {}
	try:
		pincode_dict={
		"id":str(pincode_queryset.id),
		"pincode":pincode_queryset.pincode,
		"blockName":pincode_queryset.blockPoId.name,
		"blockPoId":str(pincode_queryset.blockPoId.id)
		}
		if pincode_queryset.createdOn:
			pincode_dict["createdOn"] = pincode_queryset.createdOn.strftime("%m-%d-%Y")
		else:
			pincode_dict["createdOn"] = ""
	except Exception as e:
		app.logger.error(traceback.format_exc())
	return pincode_dict

@countries.route("/pincodes_list",methods=["POST"])
@encrypt_decrypt_before_login
def pincodes_list():
	data_status = {"responseStatus":0,"result":""}
	pincodesList = []
	try:
		data = request.decrypted_data
		blockPoId = data.get("blockPoId","")
		if not blockPoId:
			data_status["result"]="Required fields are missing!!"
			return data_status
		pincodes_queryset = Pincodes.objects(blockPoId=blockPoId,status=1).order_by("-id")
		for each_pincode in pincodes_queryset:
			pincode_dict = fetching_pincode_details(each_pincode)
			pincodesList.append(pincode_dict)

		data_status["responseStatus"]=1
		data_status["result"]="Pincodes data fetched successfully!"
		data_status["pincodesList"]=pincodesList
		return data_status   
	except Exception as e:
		app.logger.error(traceback.format_exc())
		data_status["result"]="Unable to fetch pincodes data!!"
		return data_status


@countries.route("/pincodes_based_address",methods=["POST"])
@encrypt_decrypt_before_login
def pincodes_based_address():
	data_status = {"responseStatus":0,"result":""}
	addressDetails = {}
	try:
		data = request.decrypted_data
		pincode = data.get("pincode","")
		if not pincode:
			data_status["result"]="Required fields are missing!!"
			return data_status
		pincode_queryset = Pincodes.objects(pincode=pincode,status=1).first()
		if not pincode_queryset:
			data_status["result"]="Invalid pincode!!"
			return data_status
		addressDetails={
		"id":str(pincode_queryset.id),
		"pincode":pincode_queryset.pincode,
		"blockName":pincode_queryset.blockPoId.name,
		"blockPoId":str(pincode_queryset.blockPoId.id),
		"cityId":str(pincode_queryset.blockPoId.cityId.id),
		"cityName":pincode_queryset.blockPoId.cityId.cityName,
		"stateId":str(pincode_queryset.blockPoId.cityId.stateId.id),
		"stateName":pincode_queryset.blockPoId.cityId.stateId.stateName,
		"countryId":str(pincode_queryset.blockPoId.cityId.stateId.countryId.id),
		"countryName":pincode_queryset.blockPoId.cityId.stateId.countryId.countryName
		}
		data_status["responseStatus"]=1
		data_status["result"]="Pincode based address details fetched successfully!"
		data_status["addressDetails"]=addressDetails
		return data_status   
	except Exception as e:
		app.logger.error(traceback.format_exc())
		data_status["result"]="Unable to fetch pincode based address data!!"
		return data_status