def recv_thread(mssg):
	global ClientB, ClientA, CS, Client, cipher1, cipher2, quit
	data_enc = ""
	data_unenc = ""
	prompt = "[" + ClientA + "]: "
	if (mssg == 1):
		while quit == False:
			data_enc = Client.recv(1024)
			data_unenc = cipher2.decrypt(data_enc)
			if (data_unenc == "quit()"):
				quit = True
				break
			sys.stdout.write('\r'+' '*(len(readline.get_line_buffer())+2)+'\r')
			#print "[" + ClientB + " Encrypted]: " + data_enc
			print "[" + ClientB + "]: " + data_unenc
			sys.stdout.write(prompt + readline.get_line_buffer())
			sys.stdout.flush()
			
	if (mssg == 2):
		while quit == False:
			data_enc = CS.recv(1024)
			data_unenc = cipher1.decrypt(data_enc)
			if (data_unenc == "quit()"):
				quit = True
				break
			sys.stdout.write('\r'+' '*(len(readline.get_line_buffer())+2)+'\r')
			#print "[" + ClientB + " Encrypted]: " + data_enc
			print "[" + ClientB + "]: " + data_unenc
			sys.stdout.write(prompt + readline.get_line_buffer())
			sys.stdout.flush()

    def complete(self, text, state):

        "Generic readline completion entry point."
        buffer = readline.get_line_buffer()
        line = readline.get_line_buffer().split()

        # show all commands
        if not line:
            return [c + ' ' for c in self.commands][state]

        # account for last argument ending in a space
        RE_SPACE = re.compile('.*\s+$', re.M)
        if RE_SPACE.match(buffer):
            line.append('')

        # resolve command to the implementation functions (above)
        cmd = line[0].strip()
        if cmd in self.commands:
            impl = getattr(self, 'complete_%s' % cmd)
            args = line[1:]
            if args:
                return (impl(args) + [None])[state]
            return [cmd + ' '][state]

        results = [c + ' ' for c in self.commands if c.startswith(cmd)] + [None]

        return results[state]

    def handleChatMessage(self, myChatMessage):
        # Following lines sourced from stackoverflow
        #
        # http://stackoverflow.com/questions/2082387/reading-input-from-raw-input-without-having-the-prompt-overwritten-by-other-th
        # Next line said to be reasonably portable for various Unixes
        (rows,cols) = struct.unpack('hh', fcntl.ioctl(sys.stdout, termios.TIOCGWINSZ,'1234'))

        text_len = len(readline.get_line_buffer())+2

        # ANSI escape sequences (All VT100 except ESC[0G)
        # Clear current line
        #
        sys.stdout.write('\x1b[2K')

        # Move to start of line
        #
        sys.stdout.write('\x1b[1A\x1b[2K'*int(text_len/cols))

        # Move to start of line
        #
        sys.stdout.write('\x1b[0G')

        # Print received message
        #
        print(myChatMessage.id.clientName + ": " + myChatMessage.textMessage)

        # Print the message that came before
        #
        sys.stdout.write(' >> ' + readline.get_line_buffer())
        sys.stdout.flush()

        return 1

 def p(self, status=u'未侦测到游戏数据'):
     """
     Print current deck info.
     """
     self.ui.clear()
     sys.stdout.write('\r'+' '*(len(get_line_buffer())+2)+'\r')
     print('-' * 20)
     print >>self.stream, \
         u'{1}方片{0}|{2}草花{0}|{3}红桃{0}|{4}黑桃{0}|'.format(
             Style.RESET_ALL,
             colorized_suits('D'),
             colorized_suits('C'),
             colorized_suits('H'),
             colorized_suits('S')
         )
     print('----+' * 4)
     for s in '23456789TJQKA':
         print >>self.stream, \
             '{1}{0}|{2}{0}|{3}{0}|{4}{0}|'.format(
                 Style.RESET_ALL,
                 ####
                 self.card_status('D', self.deck[('D', s)]),
                 ####
                 self.card_status('C', self.deck[('C', s)]),
                 ####
                 self.card_status('H', self.deck[('H', s)]),
                 ####
                 self.card_status('S', self.deck[('S', s)])
             )
     print('-' * 20)
     print >>self.stream, u'最后动作：{0}'.format(status)
     if status != u'未侦测到游戏数据':
         sys.stdout.write(self.ui.pmpt + get_line_buffer())
     sys.stdout.flush()

	def complete(self, text, state):
		if readline.get_line_buffer()[0] == '!':
			if text:
                # shell command, get possiblities
				fullLine = readline.get_line_buffer().split(' ')[-1]
				self.matches = self.bash_autocomplete(fullLine)
			else:
				self.matches = []
		else:
			level = len(readline.get_line_buffer().split(' '))
			if state == 0:
				if text:
					if level == 1:
						self.matches = [s for s in self.firstOptions if s and s.startswith(text)]
					elif level == 2:
						self.matches = [s for s in self.secondOptions if s and s.startswith(text)]
					else:
						self.matches = []
				else:
					if level == 1:
						self.matches = self.firstOptions[:]
					elif level == 2:
						self.matches = self.secondOptions[:]
					else:
						self.matches = []
		try:
			return self.matches[state]
		except IndexError:
			return None

    def __printToUserNow__(self):
        while True:
            # Get an item to print
            #
            text = self.printQueueNow.get()

            if text == self.CONST_EXIT_QUEUE:
                self.printQueue.task_done()
                break

            # Following lines sourced from stackoverflow
            #
            # http://stackoverflow.com/questions/2082387/reading-input-from-raw-input-without-having-the-prompt-overwritten-by-other-th
            # Next line said to be reasonably portable for various Unixes
            (rows,cols) = struct.unpack('hh', fcntl.ioctl(sys.stdout, termios.TIOCGWINSZ,'1234'))

            text_len = len(readline.get_line_buffer())+2

            # ANSI escape sequences (All VT100 except ESC[0G)
            sys.stdout.write('\x1b[2K')                         # Clear current line
            sys.stdout.write('\x1b[1A\x1b[2K'*int(text_len/cols))  # Move cursor up and clear line
            sys.stdout.write('\x1b[0G')                         # Move to start of line

            print(text)
            sys.stdout.write(' >> ' + readline.get_line_buffer())
            sys.stdout.flush()

            # Indicate we finished processing the enqueued print request
            #
            self.printQueueNow.task_done()
        return 0

    def complete(self, text, state):
        buffer = readline.get_line_buffer()
        line = readline.get_line_buffer().split()
        if not line:
            return [c + ' 'for c in self.commands[self.mode].keys()][state]
        if self.re_space.match(buffer):
            line.append('')
        cmd = line[0].strip()
        if cmd in self.commands[self.mode].keys():
            impl = getattr(self, 'complete_%s' % "extra")
            args = line[1:]
            if args:
                return (impl(args) + [None])[state]
            return [cmd + ''][state]
        if cmd.startswith('/'):
            impl = getattr(self, 'complete_%s' % "extra")
            args = line[0:]
            if args:
                return (impl(args) + [None])[state]
            return [cmd + ''][state]
        results = [
            c + '' for c in self.commands[self.mode].keys()
            if c.startswith(cmd)] + [None]

        return results[state]

    def _complete(self, text, state):
        """Generic readline completion entry point."""

        try:
            buffer = readline.get_line_buffer()
            line = readline.get_line_buffer().split()

            if " " in buffer:
                return []

            # show all commandspath
            if not line:
                all_cmnds = [c + " " for c in self.matching_words]
                if len(all_cmnds) > state:
                    return all_cmnds[state]
                else:
                    return []

            cmd = line[0].strip()

            if cmd in self.matching_words:
                return [cmd + " "][state]

            results = [c + " " for c in self.matching_words if c.startswith(cmd)] + [None]
            if len(results) == 2:
                if results[state]:
                    return results[state].split()[0] + " "
                else:
                    return []
            return results[state]

        except Exception, e:
            self._tprint("[!] Completion error: %s" % e)

 def complete(self, text, state):
     # +------/ recreating complete with iter concepts \-------{{{
     # |  TODO  | recreating complete with iter concepts
     
     # +-------/ 9929f175-52d6-4d04-81da-44dd133b7886 \--------}}}
     results = []
     tmp_results = []
     cmd_line = [[y for y in x.split(':')]  for x in shlex.split(readline.get_line_buffer())]
     if readline.get_line_buffer()[-1] == ' ':
         cmd_line.append([''])
     L.debug(cmd_line)
     if len(cmd_line) < 1:
         results = [x for x in self]
     else:
         tmp_results = []
         cmd = self.find(cmd_line[0])
         self.params = [self.params[0]] + cmd.params 
         for arg, data in zip(cmd_line, self.params + [ None ]):
             tmp_results = []
             if data:
                 tmp_results = [x for x in data.find(arg)]
     if tmp_results:
         results = tmp_results
     results = [ x + ':' for x in results if x.startswith(text.replace(':', ''))]
     return results[state]

def reader(socket):
    while True:
        data = socket.recv(4096)
        if data:
            sys.stdout.write('\r'+' '*(len(PROMPT)+len(readline.get_line_buffer()))+'\r')
            print data,
            sys.stdout.write(PROMPT + readline.get_line_buffer())
            sys.stdout.flush()

def output(mySocket):
    while True:
        data = mySocket.recv(1024)
        if not data: break
        sys.stdout.write('\r'+' '*(len(readline.get_line_buffer())+2)+'\r')
        print "<Other person>:", data
        sys.stdout.write('> ' + readline.get_line_buffer())
        sys.stdout.flush()

	def printMessage(self, username, message):
		sys.stdout.write('\r'+' '*(len(readline.get_line_buffer())+2)+'\r')
		color=32
		if username == self.username:
			color=37
		print '\033[1;%dm%s\033[0m: %s' % (color, username, message)
		sys.stdout.write(readline.get_line_buffer())
		sys.stdout.flush()

 def complete(self, text, state):
     "Generic readline completion entry point."
     buffer = readline.get_line_buffer()
     line = readline.get_line_buffer().split()
     if RE_SPACE.match(buffer):
         line.append('')
     args = line[0:]
     return (self.complete_extra(args) + [None])[state]

def printCommandIndicater():
	""" Print user command again """ 
	last_line = readline.get_line_buffer()
	if last_line.endswith('\n'):
		sys.stdout.write('server command > ')
	else:
		sys.stdout.write('server command > ' + readline.get_line_buffer())
	sys.stdout.flush()

def print_threaded(message):
    if not rawinput_running:
        print(message)
        return
    sys.stdout.write('\r'+' '*(len(readline.get_line_buffer())+2)+'\r')
    print(message)
    sys.stdout.write(CHAT_PROMPT + readline.get_line_buffer())
    sys.stdout.flush()

def refreshPrompt():
  global _canSend
  if _talkThreadRunning:
    if _canSend or (readline.get_line_buffer().__len__() < 1):
      _canSend = _canType = True
      sys.stdout.write(pr.IN_PROMPT+readline.get_line_buffer())
    else:
      sys.stdout.write(pr.BAD_PROMPT)
    sys.stdout.flush()

def output(conn, addr):
    while True:
        data = conn.recv(1024)
        if not data: break
        sys.stdout.write('\r'+' '*(len(readline.get_line_buffer())+2)+'\r')
        print "<Other person>:", data
        sys.stdout.write('> ' + readline.get_line_buffer())
        sys.stdout.flush()
    conn.close()

 def run(self):
     self.ui.clear()
     print('Initial buffer: {0}'.format(get_line_buffer()))
     while not self.stop.is_set():
         sys.stdout.write('\r'+' '*(len(get_line_buffer())+2)+'\r')
         print('Interrupting text!')
         sys.stdout.write('> ' + get_line_buffer())
         sys.stdout.flush()
         sleep(3)

 def OnAsyncSearchUsersFinished(self,cookie,users):
   cnt = 0
   print "\x1b[2K",  #Clear current line
   for user in users:
     print "\r%2d:%s (%s)\t%s\t%s" % (cnt,user.FullName,user.Handle,user.OnlineStatus,user.MoodText)
     cnt += 1
   self.printPrompt()
   print readline.get_line_buffer(),
   sys.stdout.flush()

 def OnChatMembersChanged(self,chat,mambers):
   cnt = 0
   print "\x1b[2K",  #Clear current line
   for member in members:
     print "\r%2d:%s (%s)\t%s\t%s" % (cnt,user.FullName,user.Handle,user.OnlineStatus,user.MoodText)
     cnt += 1
   self.printPrompt()
   print readline.get_line_buffer(),
   sys.stdout.flush()