#!/usr/bin/env python3
libexec_dir = __LIBEXECDIR__

offline_timeout = 5 * 60

import enum
import os
import select
import subprocess
import sys
import time

class statuses(enum.Enum):
	available = 0
	unavailable = 1
	offline = 2

own_nick = None
own_status = None

default_target_mac = None

peers = {}
class Peer:
	def __init__(self, status, nick, lastseen):
		self.status = status
		self.nick = nick
		self.lastseen = lastseen

	def __repr__(self):
		r = 'Peer(%s, %s, %s)' % (repr(self.status), repr(self.nick), repr(self.lastseen))
		if __name__ != '__main__':
			return '%s.%s' % (__name__, r)
		else:
			return r

send_queue = []
ack_failed = {}
class Message:
	def __init__(self, mac, message, queue_id = None, msgid = None):
		self.mac = mac
		self.message = message
		self.queue_id = queue_id
		self.msgid = msgid

	def __repr__(self):
		r = 'Message(%s, %s, %s, %s)' % (repr(self.mac), repr(self.message), repr(self.queue_id), repr(self.msgid))
		if __name__ != '__main__':
			return '%s.%s' % (__name__, r)
		else:
			return r

def writeall(f, b):
	written = 0
	while written < len(b):
		written += f.write(b[written:])

class ReadallError(Exception): pass

def readall(f, length):
	read = bytearray()
	while len(read) < length:
		data = f.read(length - len(read))
		if data == b'':
			raise ReadallError('Could not satisfy read of %i bytes' % length)
		read.extend(data)
	return bytes(read)

def readall_u16(f):
	u16_bytes = readall(f, 2)
	return (u16_bytes[0] << 8) | u16_bytes[1]

class MACParseError(Exception): pass

def parse_mac(text):
	parts = text.split(':')
	if len(parts) != 6:
		raise MACParseError('Invalid MAC format: %s' % text)

	try:
		parsed = bytes(int(field, 16) for field in parts)
	except ValueError:
		raise MACParseError('Invalid MAC format %s' % text)

	return parsed

class NoMatchesError(Exception): pass
class TooManyMatchesError(Exception): pass

def mac_from_name(text):
	global peers

	# Try to parse as a MAC address
	try:
		mac = parse_mac(text)
		return mac
	except MACParseError as err:
		pass

	# It was not, try to find a matching nick
	hits = 0
	for peer_mac, peer in peers.items():
		if text == peer.nick or text == '~' + peer.nick:
			hits += 1
			mac = peer_mac

	if hits == 0:
		raise NoMatchesError(text)
	elif hits > 1:
		raise TooManyMatchesError(text)

	return mac

def format_mac(mac):
	return ':'.join(mac[i:i+1].hex() for i in range(len(mac)))

def format_status(status):
	if status == 0:
		return 'available'
	elif status == 1:
		return 'unavailable'
	elif status == 2:
		return 'offline'
	else:
		raise ValueError('Unknown status %i' % status)

def timestamp():
	return time.strftime('%H:%M:%S')

class NonCharacterError(Exception): pass
class ControlCharacterError(Exception): pass

def validate_encoding(text, newline_tab_allowed):
	# We assume text is valid unicode, so we skip stuff like surrogate pairs

	for char in text:
		codepoint = ord(char)
		# Reject non-characters
		if codepoint & 0xffff in [0xfffe, 0xffff]:
			# Plane end non-character
			raise NonCharacterError(char)
		elif 0xfdd0 <= codepoint <= 0xfdef:
			# BMP non-character block
			raise NonCharacterError(char)

		# Reject control characters
		if codepoint <= 0x1f:
			# C0 control characters
			if not newline_tab_allowed or codepoint not in [0x0a, 0x09]:
				raise ControlCharacterError(char)
		elif 0x80 <= codepoint <= 0x9f:
			# C1 control characters
			raise ControlCharacterError(char)
		elif codepoint in [0x2028, 0x2029]:
			# U+2028 LINE SEPARATOR and U+2029 PARAGRAPH SEPARATOR
			raise ControlCharacterError(char)

class NickLengthError(Exception): pass

def validate_nick(nick):
	validate_encoding(nick, newline_tab_allowed = False)
	# Nick length is stored as one byte
	if len(nick.encode('utf-8')) > 255:
		raise NickLengthError

class MessageLengthError(Exception): pass

def validate_message(message):
	validate_encoding(message, newline_tab_allowed = True)
	# Maximum frame payload is 1500 bytes
	# -2 for EtherMess packet header
	# -2 for msgid
	# -2 for message length
	# = 1494
	if len(message.encode('utf-8')) > 1494:
		raise MessageLengthError

def send_message(backend, mac, message):
	encoded = message.encode('utf-8')
	writeall(backend, b'm' + mac + bytes([len(encoded) >> 8, len(encoded) & 0xff]) + encoded)

def queue_message(backend, mac, message):
	global send_queue
	global next_queue_id

	validate_message(message)

	if len(send_queue) == 0:
		# Nothing being processed atm, send directly
		send_message(backend, mac, message)
		send_queue.append(Message(mac, message))

	else:
		# Enqueue with an ID
		if send_queue[-1].queue_id is None:
			next_queue_id = 0
		else:
			next_queue_id = send_queue[-1].queue_id + 1

		send_queue.append(Message(mac, message, next_queue_id))

		print('--- Queued (%i)' % next_queue_id)

def send_status_request(backend, mac):
	writeall(backend, b'r' + mac)

def set_status_nick(backend, status, nick):
	encoded = nick.encode('utf-8')
	writeall(backend, b's' + bytes([status.value, len(encoded)]) + encoded)

def send_file_offer(backend, mac):
	writeall(backend, b'f' + mac)

def handle_user_command(backend, line):
	global own_nick, own_status
	global default_target_mac

	try:
		if len(line) > 0 and line[0] == '/':
			index = line.find(' ')
			if index != -1:
				command = line[:index]

				while index < len(line) and line[index] == ' ':
					index += 1

				rest = line[index:]
			else:
				command = line
				rest = ''

			if command == '/':
				# Send quoted message
				if default_target_mac is None:
					print('--- Default target not set, set with /target')
				else:
					queue_message(backend, default_target_mac, rest)

			elif command == '/msg':
				# Send message to target
				target, _, message = rest.partition(' ')
				mac = mac_from_name(target)
				queue_message(backend, mac, message)

			elif command == '/status':
				if rest != '':
					# Request status
					mac = mac_from_name(rest)
					if mac in peers:
						peer = peers[mac]
						print('%s === ~%s (%s) [%s]' % (timestamp(), peer.nick, peer.status.name, format_mac(mac)))
					send_status_request(backend, mac)

				else:
					# Show own
					print('--- %s' % own_status.name)

			elif command == '/peers' and rest == '':
				# List all the known peers
				for mac, peer in peers.items():
					print('--- ~%s (%s) [%s]' % (peer.nick, peer.status.name, format_mac(mac)))

			elif command == '/available' and rest == '':
				# Set status to available
				own_status = statuses.available
				set_status_nick(backend, own_status, own_nick)

			elif command == '/unavailable' and rest == '':
				# Set status to unavailable
				own_status = statuses.unavailable
				set_status_nick(backend, own_status, own_nick)

			elif command == '/nick':
				if rest != '':
					# Change nick
					if rest[0] == '~':
						# Remove the ~ from the front if it is there
						nick = rest[1:]
					else:
						nick = rest

					validate_nick(nick)

					own_nick = nick

					set_status_nick(backend, own_status, own_nick)

				else:
					# Show own
					print('--- ~%s' % own_nick)

			elif command == '/target':
				# Set default target of messages
				default_target_mac = mac_from_name(rest)

			elif command == '/sendfile':
				# Send an offer to transmit the file
				send_file_offer(backend, mac_from_name(rest))

			elif command == '/quit':
				# Quit
				return 'quit'

			else:
				# Display usage
				print('--- / <message>; /msg <target> <message>; /status [<target>]; /peers; /available; /unavailable; /nick [<nick>]; /target <target>; /sendfile <target>; /quit')

		else:
			# Send message
			if default_target_mac is None:
				print('--- Default target not set, set with /target')
			else:
				queue_message(backend, default_target_mac, line)

	except NoMatchesError as err:
		print('--- Name %s matches no peers' % err.args[0])

	except TooManyMatchesError as err:
		print('--- Name %s matches several peers' % err.args[0])

	except NonCharacterError as err:
		print('--- Error: contains non-character U+%04X' % ord(err.args[0]))

	except ControlCharacterError as err:
		print('--- Error: contains control character U+%04X' % ord(err.args[0]))

	except NickLengthError:
		print('--- Error: nick too long (max. 255B)')

	except MessageLengthError:
		print('--- Error: message too long (max. 1494B)')

def handle_status(mac, status, nick):
	global peers

	if mac not in peers:
		# Never seen before
		peers[mac] = Peer(nick = None, status = None, lastseen = None)

	if peers[mac].nick is not None and peers[mac].status != statuses.offline and nick != peers[mac].nick:
		print('%s === ~%s -> ~%s [%s]' % (timestamp(), peers[mac].nick, nick, format_mac(mac)))

	peers[mac].nick = nick

	if status != peers[mac].status:
		if status == statuses.offline:
			print('%s <<< ~%s [%s]' % (timestamp(), nick, format_mac(mac)))
		elif peers[mac].status is None or peers[mac].status == statuses.offline:
			if status == statuses.available:
				print('%s >>> ~%s [%s]' % (timestamp(), nick, format_mac(mac)))
			else:
				print('%s >>> ~%s (%s) [%s]' % (timestamp(), nick, status.name, format_mac(mac)))
		else:
			print('%s === ~%s (%s) [%s]' % (timestamp(), nick, status.name, format_mac(mac)))

	peers[mac].status = status

def nick_from_mac(mac):
	global peers

	if mac not in peers:
		return format_mac(mac)

	else:
		nick = peers[mac].nick

		# Ensure nicks are unique
		unique = True
		for peer_mac, peer in peers.items():
			if peer_mac == mac: continue

			if peer.nick == nick:
				# Nick not unique
				unique = False
				break

		if unique:
			# Unique nicks: ~nick
			return '~' + nick
		else:
			# Non-unique nicks: [MAC]~nick
			return '[%s]~%s' % (format_mac(mac), nick)

def handle_message(mac, message):
	nick = nick_from_mac(mac)
	ts = timestamp()
	if mac == default_target_mac:
		for line in message.split('\n'):
			print('%s <*%s> %s' % (ts, nick, line))
	else:
		for line in message.split('\n'):
			print('%s < %s> %s' % (ts, nick, line))

def eventloop(proc):
	global peers
	global send_queue, ack_failed

	# Create unbuffered version of stdin and close the old one as we
	# won't need it anymore
	unbuf_stdin = open(sys.stdin.buffer.fileno(), 'rb', buffering = 0)
	sys.stdin.close()

	# Set up a poll for inputs (but do output blockingly)
	poll = select.poll()
	poll.register(proc.stdout, select.POLLIN)
	poll.register(unbuf_stdin, select.POLLIN)

	input_buffer = bytearray()

	running = True
	while running:
		# Handle offline timeouts
		now = time.monotonic()
		for mac, peer in peers.items():
			if peer.lastseen + offline_timeout < now:
				peer.status = statuses.offline
				print('%s <<< (timeout) ~%s [%s]' % (timestamp(), peer.nick, format_mac(mac)))

		# Figure out how long to wait in poll()
		wait = None
		for peer in peers.values():
			if peer.status != statuses.offline:
				if wait is None or wait >= peer.lastseen + offline_timeout - now:
					wait = peer.lastseen + offline_timeout - now

		# Clamp at 0
		if wait is not None and wait < 0:
			wait = 0

		# Convert s to ms
		if wait is not None:
			wait = wait * 1000

		# Process events
		for fd, event in poll.poll(wait):
			if fd == proc.stdout.fileno() and event & select.POLLIN:
				event_type = readall(proc.stdout, 1)
				if event_type == b'v':
					# Speak version
					source_mac = readall(proc.stdout, 6)
					version, = readall(proc.stdout, 1)

					print('--- Speak version %s %i' % (format_mac(source_mac), version)) #debg

				elif event_type == b's':
					# Status
					source_mac = readall(proc.stdout, 6)
					status, = readall(proc.stdout, 1)
					nick_length, = readall(proc.stdout, 1)
					nick = readall(proc.stdout, nick_length,)

					handle_status(source_mac, statuses(status), nick.decode('utf-8'))

					peers[source_mac].lastseen = time.monotonic()

				elif event_type == b'i':
					# Msgid for message
					msgid = readall_u16(proc.stdout)
					send_queue[0].msgid = msgid

				elif event_type == b'I':
					# Failed to get msgid for message
					message = send_queue.pop(0)
					nick = nick_from_mac(message.mac)
					if message.queue_id is not None:
						print('--- Failed to send to %s (%i)' % (nick, message.queue_id))
					else:
						print('--- Failed to send to %s' % nick)

					# Send next message if there is one queued
					if len(send_queue) > 0:
						send_message(proc.stdin, send_queue[0].mac, send_queue[0].message)

				elif event_type == b'a':
					# ACK received
					source_mac = readall(proc.stdout, 6)
					msgid = readall_u16(proc.stdout)

					if source_mac in peers:
						peers[source_mac].lastseen = time.monotonic()

					# Was it for a message currently waiting?
					if len(send_queue) > 0 and send_queue[0].msgid == msgid:
						# Yes, drop is from the queue
						send_queue.pop(0)

						# Send next message if there is one queued
						if len(send_queue) > 0:
							send_message(proc.stdin, send_queue[0].mac, send_queue[0].message)

					elif msgid in ack_failed:
						# No, but it was one we thought to have failed
						message = ack_failed[msgid]
						del ack_failed[msgid]
						nick = nick_from_mac(message.mac)
						for line in message.message.split('\n'):
							print('--- %s acknowledged receive: %s' % (nick, line))

				elif event_type == b'A':
					# ACK not received (and message send failed)
					# Add it to the messages where ack failed
					message = send_queue.pop(0)
					ack_failed[message.msgid] = message
					nick = nick_from_mac(message.mac)
					if message.queue_id is not None:
						print('--- Failed to send to %s (%i)' % (nick, message.queue_id))
					else:
						print('--- Failed to send to %s' % nick)

					# Send next message if there is one queued
					if len(send_queue) > 0:
						send_message(proc.stdin, send_queue[0].mac, send_queue[0].message)

				elif event_type == b'm':
					# Message received
					source_mac = readall(proc.stdout, 6)
					message_length = readall_u16(proc.stdout)
					message = readall(proc.stdout, message_length)

					handle_message(source_mac, message.decode('utf-8'))

					if source_mac in peers:
						peers[source_mac].lastseen = time.monotonic()

				else:
					raise ValueError('Unknown event type from backend: %s' % repr(event_type))

			elif fd == proc.stdout.fileno() and event & select.POLLHUP:
				print('--- Backend exited')
				sys.exit(1)

			elif fd == unbuf_stdin.fileno() and event & select.POLLIN:
				data = unbuf_stdin.read(1024)
				input_buffer.extend(data)

				while True:
					newline_location = input_buffer.find(b'\n')
					if newline_location == -1:
						break

					line, _, input_buffer = input_buffer.partition(b'\n')
					try:
						line = line.decode('utf-8')
					except UnicodeDecodeError:
						print('--- Error: malformed utf-8')

					if handle_user_command(proc.stdin, line) == 'quit':
						writeall(proc.stdin, b'q')
						running = False

				if data == b'':
					# ^D
					writeall(proc.stdin, b'q')
					running = False

			else:
				raise Exception('Unreachable')

def main():
	global own_nick, own_status

	if len(sys.argv) != 3:
		print("Usage: %s interface nick" % os.path.basename(sys.argv[0]), file=sys.stderr)
		sys.exit(1)

	_, interface, own_nick = sys.argv

	proc = subprocess.Popen([libexec_dir + '/ethermess-backend', interface], stdin = subprocess.PIPE, stdout = subprocess.PIPE, stderr = sys.stderr, bufsize = 0)

	# Tell the backend the status and nick
	try:
		validate_nick(own_nick)

	except NonCharacterError as err:
		print('--- Error: contains non-character U+%04X' % ord(err.args[0]))
		sys.exit(1)

	except ControlCharacterError as err:
		print('--- Error: contains control character U+%04X' % ord(err.args[0]))
		sys.exit(1)

	except NickLengthError:
		print('--- Error: nick too long (max. 255B)')
		sys.exit(1)

	own_status = statuses.available
	encoded = own_nick.encode('utf-8')
	writeall(proc.stdin, bytes([own_status.value, len(encoded)]) + encoded)

	# Read our MAC
	try:
		mac = readall(proc.stdout, 6)
	except ReadallError:
		print('--- Backend exited')
		sys.exit(1)

	print('--- MAC: %s' % format_mac(mac))

	eventloop(proc)

	proc.wait()

if __name__ == '__main__':
	main()