extends Node

# Stream XMPP
# Author : AleaJactaEst
#
# https://xmpp.org/extensions/xep-0178.html
# https://www.iana.org/assignments/sasl-mechanisms/sasl-mechanisms.xhtml


# Boucle
#   - non connecte
#   - connecte en claire
#   - connecte en TLS
#   - lance l'authentification
#   - step authentification
#   - identifie

signal send_msg_debug(message:String)
signal send_msg_error(message:String)
signal new_stanza(stanza)

enum StreamState {
	END, # Stream is over. Starting with this.
	START, # Stream hass started.
	TLS, # Connection has been made and the first header is send. Let's get ssl!
	AUTHENTICATE, # We have negotiated whether to use TLS, let's authenticate.
	STANZA # We have authenticated, account is now allowed to send stanzas
}
var stream_status = StreamState.END

@export var server_ip:String = "localhost":
	set = set_server_ip, get = get_server_ip

func set_server_ip(value:String):
	server_ip = value
	
func get_server_ip() -> String:
	return server_ip

@export var port_number:int = 5222:
	set = set_port_number, get = get_port_number

func set_port_number(value:int):
	port_number = value
	
func get_port_number() -> int:
	return port_number

@export var account_name:String = "undefined@localhost":
	set = set_account_name, get = get_account_name

func set_account_name(value:String):
	account_name = value
	
func get_account_name() -> String:
	return account_name

@export var password:String = "undefined":
	set = set_password, get = get_password

func set_password(value:String):
	password = value
	
func get_password() -> String:
	return password

@export var locale:String = "en":
	set = set_locale, get = get_locale

func set_locale(value:String):
	locale = value
	
func get_locale() -> String:
	return locale

@export var xmppclient:bool = false:
	get:
		return xmppclient
	set(value):
		xmppclient = value

var try_connect:int = 0
var count_connecting_time:float = 0
var partial_stanza:String = ""
var tcp_peer:StreamPeerTCP = StreamPeerTCP.new()
var ssl_peer:StreamPeerTLS = StreamPeerTLS.new()
var tgt_peer = null
var status:StreamState = StreamState.END


func _init():
	var language = OS.get_locale()
	set_locale(language)
	tgt_peer = tcp_peer

func _process(delta):
	#Global.msg_info("TCP:%d", [tcp_peer.get_status()])
	print(server_ip, ":", port_number, " / get_status:" , tcp_peer.get_status(), " / count_connecting_time:", count_connecting_time, " / stream_status:", stream_status)
#	if tcp_peer.get_status() == StreamPeerTCP.STATUS_NONE and stream_status == self.StreamState.TLS:
#		#negotiate_tls()
#		print("negotiate_tls")
#		pass
	if (tgt_peer.get_status() == StreamPeerTCP.STATUS_CONNECTED) :
		print("STATUS_CONNECTED:", delta)
		if (tgt_peer.has_method("poll")):
			tgt_peer.poll()
		if tgt_peer.get_available_bytes()>0:
			var response = tgt_peer.get_string(tgt_peer.get_available_bytes())
			send_msg_debug.emit("Stream: response: " + response)
			if stream_status == self.StreamState.STANZA:
				#collect_stanza(remove_stream_header(response))
				Global.msg_info("", [])
				print("collect_stanza")
			else:
				print("stream_process")
				stream_process(remove_stream_header(response))
#			print(remove_stream_header(response))
		elif stream_status == self.StreamState.END:
			start_stream()
			stream_status = self.StreamState.START
		count_connecting_time = 0
	if tgt_peer.get_status() == StreamPeerTCP.STATUS_CONNECTING:
		print("STATUS_CONNECTING:", delta)
		count_connecting_time += delta
		if (tgt_peer.has_method("poll")):
			tgt_peer.poll()
	if count_connecting_time > 60: # (1 -> 1s) if it took more than 1s to connect, error
		print("**** Stream: Stuck connecting, will now disconnect")
		Global.msg_error("Stream: Stuck connecting, will now disconnect", [])
		send_msg_debug.emit("Stream: Stuck connecting, will now disconnect")
		tgt_peer.disconnect_from_host() #interrupts connection to nothing
		set_process(false) # stop listening for packets
		try_connect = 20
		stream_status = self.StreamState.END
	if tgt_peer.get_status() == StreamPeerTCP.STATUS_NONE and xmppclient:
		print("connect_to_server:", xmppclient)
		connect_to_server()
		xmppclient = false


func connect_to_server():
	""" Connect to the server ip and port, and start checking whether there's stream info yet. """
	if tcp_peer.get_status() == StreamPeerTCP.STATUS_CONNECTED:
		pass
	if try_connect == 0 and tcp_peer.get_status() == StreamPeerTCP.STATUS_NONE:
		#print("-> ", server_ip, ":", port_number, "/" , tcp_peer.get_status())
		var res = tcp_peer.connect_to_host(server_ip, port_number)
		if res == OK:
			count_connecting_time = 0
			stream_status = self.StreamState.END
			set_process(true)
			tgt_peer = tcp_peer
		else:
			try_connect = 20
	else:
		try_connect -= 1


func send_string(stanza:String) ->void:
	""" Send a string in the appropriate encoding. """
	send_msg_debug.emit("Sending data: '%'".format([stanza], "%"))
	tgt_peer.put_data(stanza.to_utf8_buffer())


func conv_string_to_PackedByteArray(message:String) -> PackedByteArray:
	return message.to_ascii_buffer()


#func send_PackedByteArray(message:PackedByteArray) -> void:
#	""" Send a PackedByteArray """
#	send_msg_debug.emit("Sending data: '" + message.get_string_from_utf8() + "'")
#	tgt_peer.put_data(message)


func start_stream() -> void:
	""" Send the stream header.
		Needs to be done several times over stream negotiation.
	"""
	var server_name = account_name.split("@")[-1]
	var message:String = "<?xml version='1.0'?>" + \
		"<stream:stream" + \
		" xmlns=\"jabber:client\"" + \
		" version=\"1.0\"" + \
		" xmlns:stream=\"http://etherx.jabber.org/streams\"" + \
		" from=\"" + account_name + "\" " + \
		" to=\"" + server_name + "\" " + \
		" xml:lang=\"en\"" + \
		" > "
	#	" from=\"" + account_name + "\" " + \
	# + locale + "'"  + 
	print(message)
	send_string(message)

func remove_stream_header(text :String) -> String:
	var index = 0
	if text.begins_with("<?") :
		# Strip xml header
		index = text.find("?>")
		text = text.substr(index+2).strip_edges()
	# strip stream header
	var rg = RegEx.new()
	rg.compile("<\\s?(stream|stream:stream)\\s")
	var result = rg.search(text)
	if result:
		send_msg_debug.emit("Stream: Response header received")
		index = text.find(">", result.get_end())
		text = text.substr(index+1)
	return text


func stream_process(response :String = "") -> void:
	""" Try to authenticate using SASL. We can currently only do plain. 
		For SCRAM based methods, we need HMAC at the very least. 
	"""

	if (!response.length() == 0 and stream_status != self.StreamState.STANZA):
		if response.begins_with("<stream:error"):
			var stream_error = XMPPStreamError.new()
			stream_error.parse_from_xml(response)
			var error_name = stream_error.error_name_for_enum(stream_error.error_type)
			var error = tr('A stream error of type "%" occured, or in other words: % \n\nStream errors cannot be recovered from, the connection will be closed.'.format([error_name, stream_error.human_friendly_error_message()], "%"))
			error.emit(error)

		elif response.begins_with("<stream:features"):
			var stream_features = XMPPStreamFeatures.new()
			stream_features.parse_from_xml(response)

			if stream_features.parsedDictionary.has("starttls"):
				send_msg_debug.emit("Stream: sending request for ssl")
				var request_tls = "<starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>"
				send_string(request_tls)
				stream_status = self.StreamState.TLS

			elif stream_features.parsedDictionary.has("mechanisms"):
				print("response:", response)
				var authentication_methods = stream_features.parsedDictionary["mechanisms"]
				if (authentication_methods.size() > 0):
					var tmp:String = ""
					var sep:String = ""
					for item in authentication_methods:
						tmp += sep + item
						sep = ", "
					send_msg_debug.emit("Stream: authentication methods: " + tmp)
					negotiate_sasl(authentication_methods)
					stream_status = self.StreamState.AUTHENTICATE

		else:
			if stream_status == StreamState.TLS:
				if response.begins_with("<proceed"):
					send_msg_debug.emit("Stream: gotten go ahead for ssl")
					negotiate_tls()
				else:
					send_msg_error.emit(tr("Tls negotiation failed."))

			elif stream_status == StreamState.AUTHENTICATE:
				if response.begins_with("<success"):
						stream_status = self.StreamState.STANZA
#						start_stream()
						return
				else:
					var parser = XMLParser.new()
#					parser.open_buffer(response.to_utf8())
					var failure_text = []
					while parser.read() == OK:
						if parser.get_node_type() == XMLParser.NODE_TEXT:
							failure_text.append(parser.get_node_data())
					print(failure_text)
#					failure_text = tr("Authentication failed! %".format([PoolStringArray(failure_text).join(" ")], "%"))
					var msg:String = ""
					for item in failure_text:
						msg += item
					send_msg_error.emit(msg)
	elif stream_status == self.StreamState.START:
		connect_to_server()
		start_stream()
	else:
		print("Mystery stream status: "+str(stream_status))


func negotiate_tls() -> void:
	#var ssl_peer = StreamPeerTLS.new()
	# I am unsure how to validate the ssl certificate for an unknown host?
	#var ssl_succes = FAILED
	var options:TLSOptions = TLSOptions.client_unsafe()
	print("accept_stream")
	#var ssl_succes = ssl_peer.accept_stream(tcp_peer, options)
	var ssl_succes = ssl_peer.connect_to_stream(tcp_peer, "localhost", options)
	print("resultat:", ssl_succes)
	if ssl_succes == OK:
		send_msg_debug.emit("Stream: switched to SSL!")
		print("get_status:", ssl_peer.get_status())
		# Wait connection done
		while ssl_peer.get_status() == StreamPeerTLS.STATUS_HANDSHAKING:
			ssl_peer.poll()
		print("get_status:", ssl_peer.get_status())
		tgt_peer = ssl_peer
		start_stream()
		print("get_status:", ssl_peer.get_status())
		print("-----")
		#stream_status == StreamState.START
	else:
		send_msg_error.emit("SSL failed, error %".format([ssl_succes], "%"))


func negotiate_sasl(authentication_methods : Array) -> void:
	if (!authentication_methods.has("PLAIN")):
		end_stream()
	send_msg_debug.emit("Stream: sending request for plain")
	var msg:PackedByteArray = PackedByteArray()
	msg.push_back(0)
	var t = account_name.split("@")[0]
	msg += t.to_ascii_buffer()
	#msg += conv_string_to_PackedByteArray(account_name.split("@")[0])
	msg.push_back(0)
	msg += password.to_ascii_buffer()
	print("7:", msg)
	
	var auth_account:String = Marshalls.raw_to_base64(msg)
	var request_sasl:String = "<auth" + \
						" xmlns='urn:ietf:params:xml:ns:xmpp-sasl'" + \
						" mechanism='PLAIN'" + \
						" >" + auth_account + "</auth>"
	send_string(request_sasl)


func end_stream() -> void:
	""" End the stream """
	send_msg_debug.emit("Stream: Ending stream")
	send_string("</stream>")
	if tcp_peer.has_method("disconnect_from_stream"):
		tcp_peer.disconnect_from_stream()
	else:
		tcp_peer.disconnect_from_host()
	set_process(false)
	stream_status = StreamState.END