class MessageReceiver(Thread):
    """
    This is the message receiver class. The class inherits Thread, something that
    is necessary to make the MessageReceiver start a new thread, and it allows
    the chat client to both send and receive messages at the same time
    """

    def __init__(self, client, connection):
        super(MessageReceiver, self).__init__()
        """
        This method is executed when creating a new MessageReceiver object
        """

        # Flag to run thread as a deamon. A deamon is a process that runs in the background.
        self.daemon = True

        self.parser = MessageParser()
        self.client = client
        self.connection = connection
        self.start()

    def run(self):
        while True:
            received_message = self.connection.recv(4096)
            try:
                print self.parser.parse(received_message)
            except:
                pass

class MessageReceiver(Thread):
    """
    This is the message receiver class. The class inherits Thread, something that
    is necessary to make the MessageReceiver start a new thread, and it allows
    the chat client to both send and receive messages at the same time
    """

    def __init__(self, client, connection):
        """
        This method is executed when creating a new MessageReceiver object
        """

        # Flag to run thread as a deamon
        
	#self.client=client
        self.connection = connection
        # tODO: Finish initialization of MessageReceiver
        super(MessageReceiver,self).__init__()
       

    def run(self):
        # tODO: Make MessageReceiver receive and handle payloads
        self.MessageParser = MessageParser()
        #s_thread = MessageParser(payload)
        #s_thread.start()
        while True:
            payload = self.connection.recv(4096)
            #print('We now listening for input from server.' + payload)
            self.MessageParser.parse(payload)

    def run(self):
        # TODO: Make MessageReceiver receive and handle payloads
        parser = MessageParser()
        while True:
            self.received = self.connection.recv(1024)        # v2
            # print self.received

            print parser.parse(self.received)

class Client:
    """
    This is the chat client class
    """

    def __init__(self, host, server_port):
        """
        This method is run when creating a new Client object
        """

        # Set up the socket connection to the server
        self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        
        # TODO: Finish init process with necessary code
        self.host = host
        self.server_port = server_port
        
        self.messageParser = MessageParser()
        self.messageReceiver = MessageReceiver(self, self.connection)
        self.run()

    def run(self):
        """
        Main process of the client. Waits for input from user
        """
        self.connection.connect((self.host, self.server_port))

        self.messageReceiver.start()
        
        print 'Client running...\nType \'quit\' to end or \'help\' for info'
        
        while True:
            command = raw_input()
  
            if command == 'quit':
                self.disconnect()
                print 'Client closing'
                break
            
            self.send_payload(self.messageParser.parse_dataToSend(command))	
            
    def disconnect(self):
        """
		Close sock connection 
		"""
        self.connection.close()

    def receive_message(self, message):
        """
		Prints received message after it's parsed
		"""
        print self.messageParser.parse(message)

    def send_payload(self, data):
        """
		Sends data to server
		"""
        self.connection.send(data)

 def receive_message(self, message):
     #Decode message
     msg_parser = MessageParser()
     #print(message)
     #if message is None:
      #   print('oops its none')
     decoded_message = msg_parser.parse(message)
     #Print the "handled" response
     print(decoded_message)

class Client:
    """
    This is the chat client class
    """

    def __init__(self, host, server_port):
        """
        This method is run when creating a new Client object
        """
        self.serverport = server_port
        self.h = host
        # Set up the socket connection to the server
        self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.MParser = MessageParser()
        self.MReceiver = MessageReceiver(self, self.connection)
        self.run()


    def run(self):
        # Initiate the connection to the server
        self.connection.connect((self.h, self.serverport))
        self.MReceiver.start()

        while True:
            userInput = raw_input()
            try:
                if userInput:
                    request, content = userInput.split()
                    if not content:
                        content = None
                payload = {
                    'request': request,
                    'content': content
                }
                self.send_payload(payload)

            except KeyboardInterrupt:
                self.disconnect()

    def handleInput(self, userInput):
        message = userInput.split(' ')

    def disconnect(self):
        self.connection.close()
        print "Server disconnected."


    def receive_message(self, message):
        print self.MParser.parse(message)

    def send_payload(self, data):
        payload = json.dumps(data)
        self.connection.send(payload)

class Client:
    """
    This is the chat client class
    """
    def __init__(self, host, server_port):
        """
        This method is run when creating a new Client object
        """

        # Set up the socket connection to the server
        self.connection = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

        self.messageParser = MessageParser()
        self.host = ""
        self.server_port = 9998
        # TODO: Finish init process with necessary code
        self.run()
        self.messageReceiver = MessageReceiver(self,self.connection)
        self.messageReceiver.start()

    def run(self):
        # Initiate the connection to the server
        self.connection.connect((self.host, self.server_port))

        
    def disconnect(self):
        self.messageReceiver.send_disconnect()
        self.connection.close()
        quit()

    def receive_message(self, message):
        self.messageParser.parse(self.printer, message)

    def printer(self,time,sender,message_type,message):
        melding = ("\n[" +
                time +" : " + message_type + "] " +
                sender+ ": " + message + "\n>>> ")
        print melding

    def send_payload(self, data):
        if data == "getHistory":
            self.messageReceiver.getHistory()
        elif data == "getNames":
            self.messageReceiver.getNames()
        elif data == "getHelp":
            self.messageReceiver.getHelp()
        else:
            self.messageReceiver.sendMessage(data)

    def login(self, data):
        brukerNavn = self.messageParser.parse_login(data)
        self.messageReceiver.send_login(brukerNavn)