#!/usr/bin/env python3
import sys

oldexcepthook = sys.excepthook
def newexcepthook(type,value,traceback):
	oldexcepthook(type,value,traceback)
	#input("Press ENTER to quit.")
sys.excepthook = newexcepthook

import os
p = os.path.join
pUp = os.path.dirname
s = False
if getattr(sys, 'frozen', False) and hasattr(sys, '_MEIPASS'):
	s = os.path.realpath(sys.executable)
else:
	s = os.path.realpath(__file__)
sp = pUp(s)

# script start
import subprocess
import socket
import threading
import queue

def eprint(*args, **kwargs): print(*args, file=sys.stderr, **kwargs)

bufferSize = 8096 # buffer size in bytes
queueLengthWait = 10 # How many buffers can be in the queue before waiting for it to empty? 0 for infinite, maxAccumulatedData comes into play. Raise for smoother playback, lower for less delay.
maxAccumulatedData = 50*1000*1000 # If queueLengthWait is 0, how much data can be in an outbound thread's queue at maximum before the connection is closed?
timeout = 15 # timeout in seconds
connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

class stdoutThread(threading.Thread):
	def __init__(self):
		threading.Thread.__init__(self)
		self.queue = queue.Queue()
	
	def run(self):
		while True:
			data = self.queue.get(timeout=timeout)
			sys.stdout.buffer.write(data)

class stdinThread(threading.Thread):
	def __init__(self,connection):
		threading.Thread.__init__(self)
		self.queue = queue.Queue(queueLengthWait)
		self.connection = connection
	
	def run(self):
		try:
			while True:
				accumulatedData = self.queue.qsize() * bufferSize
				
				if queueLengthWait < 1:
					eprint("Accumulated MB: " +str(accumulatedData/1000000))
				
					if accumulatedData > maxAccumulatedData:
						eprint("Accumulated data limit reached. Closing.")
						self.connection.close()
						self.queue = False
						return
				data = self.queue.get()
				self.connection.sendall(data)
		except:
			self.connection.close()
			self.queue = False
			raise

def listToCommand(lst):
	cmd = ""
	for arg in lst:
		arg = arg.replace("\\","\\\\")
		arg = arg.replace(",","\\,")
		cmd += arg + ","
	
	return cmd[:-1]

def commandToList(cmd):
	args = []
	cArg = ""
	escape = False
	for letter in cmd:
		if escape == True:
			cArg += letter
			escape = False
			continue
		
		if letter == "\\":
			escape = True
			continue
		
		if letter == ",":
			if cArg == "": continue
			args.append(cArg)
			cArg = ""
			continue
		
		cArg += letter
	
	args.append(cArg)
	
	return args

def makePayload(lst):
	cmdText = listToCommand(lst)
	cmdBytes = cmdText.encode("utf-8")
	cmdBytes += b" " * (1024 - len(cmdBytes))
	return cmdBytes

def stringToAddressTuple(addr):
	rtn = addr.rsplit(":",1)
	rtn[1] = int(rtn[1])
	rtn = tuple(rtn)
	return rtn

def main():
	global serverAddr
	serverAddr = stringToAddressTuple(sys.argv[1])
	global bufferSize
	
	eprint("Connecting to server...")
	connection.settimeout(timeout)
	connection.connect(serverAddr)
	eprint("Sending payload...")
	connection.sendall(makePayload(sys.argv[2:]))
	eprint("Receiving payload...")
	args = commandToList(connection.recv(1024).decode("utf-8").rstrip(" "))
	
	if sys.argv[2] == "watch":
		bufferSize = int(args[0])
		try:
			eprint("Receiving data...")
			while True:
				data = connection.recv(bufferSize)
				if data == b"": return
				sys.stdout.buffer.write(data)
		except:
			connection.close()
			raise
	
	if sys.argv[2] == "broadcast":
		bufferSize = int(sys.argv[3])
		try:
			eprint("Sending data...")
			while True:
				data = sys.stdin.buffer.read(bufferSize)
				connection.sendall(data)
		except:
			connection.close()
			raise

if __name__ == '__main__':
	main()