#!/usr/bin/env python


APPLICATION = "/home/david/Savage2/savage2.bin"
HOST, PORT = "localhost", 8182

import pickle
import Queue
import sys, subprocess, re
import socket, threading, SocketServer
import time
import readline
from collections import deque


class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler):

	def handle(self):
		Savage2ConsoleHandler.addChannel (self.onConsoleMessage)
		while (True):
			line = self.request.recv (1024);
			Savage2SocketHandler.put (line);
			Savage2SocketHandler.broadcast ();

	def onConsoleMessage (self, line):
		self.request.send (line + "\n")


class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
	pass


class Savage2Thread(threading.Thread):

	process = None

	def run(self):
		ansisequence = re.compile(r'\x1B\[[^A-Za-z]*[A-Za-z]|\x1b\([^A-Za-z]*[A-Za-z]')

		Savage2SocketHandler.addChannel (self.onSocketMessage)
		Savage2DaemonHandler.addChannel (self.onDaemonMessage)

		self.launchDaemon ()

		while (not self.process.poll ()):
			if (self.process.returncode != None):
				break

			line = ansisequence.sub ('' , self.process.stdout.readline ()).replace ("\t", "").rstrip ("\r\n").strip ("\r")
			line = line.replace ("^[[?1049h^[[1;52r^[[m^[(B^[[4l^[[?7h^[[?25l^[[H^[[2J^[[41d", '')

			if (not line):
				continue

			#print "(Debug)Thread>: %s: size> %s\n" % (repr (line), len(line))
			Savage2ConsoleHandler.put (line)
			Savage2ConsoleHandler.broadcast ()

		if (self.process.returncode == None):
			print "Error: process %s(%s) has been terminated." % (APPLICATION, self.process.pid)

	def launchDaemon (self):
		self.process = subprocess.Popen ([APPLICATION, "Set host_dedicatedServer true"], stdin=subprocess.PIPE, stdout=subprocess.PIPE)

	def onSocketMessage (self, line):
		self.process.stdin.write (line + "\n")

	def onDaemonMessage (self, line):
		self.process.stdin.write (line + "\n")


class Savage2ConsoleHandler():

	def __init__(self):
		Savage2ConsoleHandler.queue = deque()
		Savage2ConsoleHandler.channel = []

	@ staticmethod
	def addChannel (cb):
		Savage2ConsoleHandler.channel.append (cb)

	@ staticmethod
	def put (line):
		Savage2ConsoleHandler.queue.append (line)

	@ staticmethod
	def broadcast ():
		line = Savage2ConsoleHandler.get ()
		for cb in Savage2ConsoleHandler.channel:
			cb (line)

	@ staticmethod
	def get():
		try:
			return Savage2ConsoleHandler.queue.popleft ()
		except:
			return None

class Savage2SocketHandler():

	def __init__(self):
		Savage2SocketHandler.queue = deque()
		Savage2SocketHandler.channel = []

	@ staticmethod
	def addChannel (cb):
		Savage2SocketHandler.channel.append (cb)

	@ staticmethod
	def put (line):
		Savage2SocketHandler.queue.append (line)

	@ staticmethod
	def broadcast ():
		line = Savage2SocketHandler.get ()
		for cb in Savage2SocketHandler.channel:
			cb (line)

	@ staticmethod
	def get():
		try:
			return Savage2SocketHandler.queue.popleft ()
		except:
			return None

class Savage2DaemonHandler():

	def __init__(self):
		Savage2DaemonHandler.queue = deque()
		Savage2DaemonHandler.channel = []

	@ staticmethod
	def addChannel (cb):
		Savage2DaemonHandler.channel.append (cb)

	@ staticmethod
	def put (line):
		Savage2DaemonHandler.queue.append (line)

	@ staticmethod
	def broadcast ():
		line = Savage2DaemonHandler.get ()
		for cb in Savage2DaemonHandler.channel:
			cb (line)

	@ staticmethod
	def get():
		try:
			return Savage2DaemonHandler.queue.popleft ()
		except:
			return None


class Savage2Daemon():

	thread = None

	def __init__(self):

		Savage2ConsoleHandler ()
		Savage2SocketHandler ()
		Savage2DaemonHandler ()

		Savage2ConsoleHandler.addChannel (self.onConsoleMessage)
		Savage2SocketHandler.addChannel (self.onSocketMessage)

		self.thread = Savage2Thread ()
		self.thread.daemon = True
		self.thread.start ()

	def onConsoleMessage (self, line):
		print "(Debug)onConsoleMessage> %s\n" % line

	def onSocketMessage (self, line):
		print "(Debug)onSocketMessage> %s\n" % line

	def enableServer(self):
		server = ThreadedTCPServer((HOST, PORT), ThreadedTCPRequestHandler)

		server_thread = threading.Thread(target=server.serve_forever)
		server_thread.setDaemon(True)
		server_thread.start ()

		ip, port = server.server_address
		print "Started daemon: %d" % port

if __name__ == "__main__":

	savage2Daemon = Savage2Daemon ()
	savage2Daemon.enableServer ()
	try:
		while True:
		
			line = raw_input("> ")
			Savage2DaemonHandler.put (line);
			Savage2DaemonHandler.broadcast ();
	
			pass

	except KeyboardInterrupt:

		print "Exit"

	savage2Daemon = None