# -*- coding: utf-8 -*-
import os
import json
import tornado.ioloop
import tornado.web
import tornado.websocket
import tornado.tcpserver

app = None
class ServerSide:

    def __init__(self, local_port, remote_port):
        self._local_port = int(local_port)
        self._remote_port = int(remote_port)
        app = self
        self.local = None
        self.remote = None
        self.localHandlerHash = {}

    def run(self):
        webapp = tornado.web.Application([
            (r"/websocket", LocalSocketHandler)
        ], {})
        webapp.listen(self._local_port)

        remote_server = RemoteServer()
        remote_server.listen(self._remote_port)

        self.local = webapp
        self.remote = remote_server
        tornado.ioloop.IOLoop.instance().start()

    def addRemoteConn(conn):
        pass

    def addLocalConn(conn):
        self.localHandlerHash[conn] = conn

    def removeLocalConn(conn):
        del self.localHandlerHash[conn]

class RemoteServerConnection(object):

    def __init__(self, steam, address):
        self.steam = steam
        self.address = address

    async def handle_stream(self):
        while True:
            try:
                data = await self.stream.read_until(b"\n")
                await self.stream.write(data)
            except tornado.iostream.StreamClosedError:
                break

class RemoteServer(tornado.tcpserver.TCPServer):

    async def handle_stream(self, stream, address):
        conn = RemoteServerConnection(steam, address)
        app.addRemoteConn(conn)
        conn.handle_stream()

class LocalSocketHandler(tornado.websocket.WebSocketHandler):

    def open(self):
        self._recvBuf = ''
        app.addLocalConn(self)

    def on_message(self, message):
        self._recvBuf += message
        self.parsePacket()

    def on_close(self):
        app.removeLocalConn(self)

    def parsePacket(self):
        if len(self._recvBuf) <= 0:
            return
        lines = self._recvBuf.split('\n')
        if self._recvBuf[-1] == '\n':
            self._recvbuf = lines[-1]
            lines = lines[:-1]
        for line in lines:
            msg = json.loads(line)
            self.dispatchMsg(msg)

    def dispatchMsg(self, msg):
        pass