#!/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 threading
import socket
import struct

addr = ("127.0.0.1",21779)

threads = {}
threadId = 0
threadsLock = threading.Lock()
close = False

eventHandlers = {}
eventHandlersLock = threading.Lock()

def runCode(str, lcs = False, description = "loose-code"):
	if lcs == False: lcs = {}
	code = compile(str,description,"exec")
	exec(code,globals(),lcs)
	return lcs

def runScript(sf, lcs = False):
	if lcs == False: lcs = {}
	with open(sf) as script:
		runCode(script.read(),lcs,sf)
		return lcs

def getModlist(path):
	modList = []
	for root,dirs,files in os.walk(path):
		for file in dirs:
			ffile = p(root,file)
			lfile = ffile.replace(path + os.path.sep,"",1)
			if lfile[0] == "-": continue
			if lfile[0] == "[" and lfile[-1] == "]":
				modList = modList + sorted(getModlist(ffile))
				continue
			
			modList.append(ffile)
		break
	
	return modList

def triggerEvent(event,*args,**kwargs):
	eventHandlersLock.acquire()
	handlers = eventHandlers.copy()
	eventHandlersLock.release()
	
	if not event in handlers: return
	for func in handlers[event]:
		cancel = func(event,*args,**kwargs)
		if cancel: return True
	
	return False

def addEventHandler(event,func):
	eventHandlersLock.acquire()
	if not event in eventHandlers: eventHandlers[event] = []
	eventHandlers[event].append(func)
	eventHandlersLock.release()

def sendResponse(connection,data):
	connection.sendall(len(data).to_bytes(4,"big") + data)

class connectionThread(threading.Thread):
	global threadsLock
	
	def __init__(self,threadId,connection,address):
		threading.Thread.__init__(self)
		self.threadId = threadId
		self.connection = connection
		self.address = address
		self.closed = False
		self.user = False
		self.lock = threading.Lock()
	
	def closeThread(self):
		self.lock.acquire()
		threadsLock.acquire()
		try:
			self.connection.close()
		except:
			print("failed to close connection, ignoring.")
			pass
		
		del threads[str(self.threadId)]
		print("thread closed: " +str(self.threadId)+ " (open: " +str(len(threads))+ ")")
		self.closed = True
		threadsLock.release()
		self.lock.release()
	
	def run(self):
		self.lock.acquire()
		# inform about connection
		print("thread opened: " +", ".join((str(self.threadId),str(self.address))))
		self.lock.release()
		
		while True:
			try:
				# get request length
				data = b''
				data = self.connection.recv(4)
				
				if not data:
					self.closeThread()
					return
				
				requestLength = int.from_bytes(data,"big")
				
				# inform about request
				cancel = triggerEvent("onPreRequest",self,requestLength)
				self.lock.acquire()
				if self.closed:
					self.lock.release()
					return
				self.lock.release()
				if cancel: continue
				
				# process request
				cancel = triggerEvent("onRequest",self,requestLength)
				self.lock.acquire()
				if self.closed:
					self.lock.release()
					return
				self.lock.release()
				if cancel: continue
			except Exception as e:
				#self.lock.release() - fix this
				cancel = False
				try:
					cancel = triggerEvent("onException",self,e)
				except:
					self.closeThread()
					raise
				
				if cancel: continue
				self.closeThread()
				raise e

modulesLoaded = []
modulePath = p(sp,"modules")
def moduleRun(localModule):
	if not localModule in modulesLoaded: modulesLoaded.append(localModule)
	print("> " +localModule+ "...")
	runScript(p(modulePath,localModule,"module.py"))

def moduleDepends(localModules):
	if type(localModules) == str: localModules = [localModules]
	
	for localModule in localModules:
		if localModule in modulesLoaded: return
		print("depend ",end="")
		moduleRun(localModule)

def main():
	print("Loading modules...")
	for path in getModlist(modulePath):
		if os.path.isfile(p(path,"module.py")):
			localModule = path.replace(modulePath + os.path.sep,"",1)
			if not localModule in modulesLoaded:
				moduleRun(localModule)
	
	print("\nServing on " +":".join(map(str,addr))+ "!")
	
	global socketServer
	socketServer = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	socketServer.bind(addr)
	socketServer.listen(1000)
	
	global threadId
	global close
	while True:
		connection, address = socketServer.accept()
		threadsLock.acquire()
		if close: threadsLock.release(); break
		cancel = triggerEvent("onConnect",connection,address)
		if close: threadsLock.release(); break
		if cancel: continue
		
		threadId += 1
		while str(threadId) in threads:
			threadId += 1
		
		thread = connectionThread(threadId,connection,address)
		threads[str(threadId)] = thread
		thread.start()
		threadsLock.release()

if __name__ == '__main__':
	main()