import json

GMCP = 201 #this is not chr'd for simplicity of

interaction with the mushclient callbacks
IAC = chr(255)
SB = chr(250)
SE = chr(240)
DO =  chr(0xFD)

def Send_GMCP_Packet(packet):
	try:
		if packet is None:
			world.Note( "Send_gmcp_packet got

a null packet.")
			return True
		world.SendPkt(IAC + SB + chr(GMCP) +

packet.replace("\\255", "\\255\\255") + IAC + SE)
	except:
		pass
		#logger.dump()
	return True

def OnPluginInstall():
	pass
	#cmds = ("ql", "allies")
	#send(sys["separator"].join(cmds))
	#load_roomdb()

def OnPluginTelnetSubnegotiation (msg_type, data):
	if msg_type != GMCP:
		return True
	if gmcp_debug:
		world.Note(str(data))
	if data:
		gmcp_decode(data)
	return True


#Note that the returns are manditory.
#Mush client needs the implicit return due to python's

inherent None return value
def OnPluginTelnetRequest (msg_type, data):
	if msg_type == GMCP and data == "WILL":
		return True
	if msg_type == GMCP and data == "SENT_DO":
		Send_GMCP_Packet ('Core.Hello { "client":

"MUSHclient", "version": "4.80" }')
		Send_GMCP_Packet ('Core.Supports.Set [

"Char 1", "Char.Items 1", "Room 1", "Comm.Channel 1",

"IRE.Rift 1" ]')
		return True
	return False

#standard decoding stuff
def _decode_list(data):
	rv = []
	for item in data:
		if isinstance(item, unicode):
			item = item.encode('utf-8')
		elif isinstance(item, list):
			item = _decode_list(item)
		elif isinstance(item, dict):
			item = _decode_dict(item)
		rv.append(item)
	return rv

def _decode_dict(data):
	rv = {}
	for key, value in data.iteritems():
		if isinstance(key, unicode):
			key = key.encode('utf-8')
		if isinstance(value, unicode):
			value = value.encode('utf-8')
		elif isinstance(value, list):
			value = _decode_list(value)
		elif isinstance(value, dict):
			value = _decode_dict(value)
		rv[key] = value
	return rv

def gmcp_decode(data):
	if " " in data:
		cmd, data = data.split(" ", 1)
		data = json.loads(data,

object_hook=_decode_dict)
	else:
		cmd = data
		data = None
	gmcp.update(cmd, data)

class GmcpHandler(object):
	def __init__(self):
		self.map = {
			"Char.Vitals" : self.char_vitals,
			"Char.Status" : self.char_status,
			"Char.Defences.Add" :

self.char_defences_add,
			"Char.Defences.List" :

self.char_defences_list,
			"Char.Defences.Remove" :

self.char_defences_remove,
			"Char.Afflictions.Add" :

self.char_afflictions_add,
			"Char.Afflictions.Remove" :

self.char_afflictions_remove,
			"Char.Afflictions.List" :

self.char_afflictions_list,
			"Room.Info" : self.room_info,
			"Room.Players" :

self.room_players,
			"Room.AddPlayer" :

self.room_add_player,
			"Room.RemovePlayer" :

self.room_remove_player,
			"Comm.Channel.Start" :

self.channel_start,
			"Comm.Channel.Text" :

self.channel_text,
			"Comm.Channel.End" :

self.channel_end,
		"Char.Items.Add" : self.char_items_add,
		"Char.Items.Remove" :

self.char_items_remove,
		"Char.Items.List" : self.char_items_list,
		}
		#self.evm = EventManager()

	#def lost_bal(self, bal):
		#bals[bal].used()
		#self.evm.fire(Event("bal_off", bal))

	#def gained_bal(self, bal):
		#bals[bal].regained()
		#self.evm.fire(Event("bal_on", bal))

	def char_status(self, data):
		pass
		sys["prof"] = data.get("prof", sys

["default_prof"]).lower()

	def char_vitals(self, data):
		pass
		#if afflictions["blackout"].has():
			#return
		#for bal in ("bal", "eq", "herb",

"focus", "tree", "purge", "salve", "pipe"):
			#if bals[bal].bal != int(data

[bal]):
				#if bals[bal].bal:
					#self.lost_bal

(bal)
				#else:
					#self.gained_bal

(bal)
		#left = data["leftwield"]
		#right = data["rightwield"]
		#me.wield_left = None if left == 0 else

weapon_manager.get_by_id(int(left))
		#me.wield_right = None if right == 0 else

weapon_manager.get_by_id(int(right))
		#if data.has_key("bleed"):
			#self.evm.fire(Event("bleeding",

int(data["bleed"]) / IMPERIAN_STAT_CAST))
		#if data.has_key("rage"):
			#berserker_set_rage(data["rage"])
		#elif data.has_key("kai"):
			#monk_set_kai(int(data["kai"]))

	def char_afflictions_add(self, data):
		pass
		#aff = normalise_aff(aff)
		#if afflictions.has_key(aff):
			#afflictions[aff].gained()
		#else:
			#alert("Unhandled aff %s in

char_afflictions_add" % data["name"])

	def char_afflictions_remove(self, data):
		pass
		#for aff in data:
			#try:
				#aff = normalise_aff(aff)
				#afflictions[aff].cured

(forced=True)
			#except:
				#continue #don't judge me

	def char_afflictions_list(self, data):
		pass
		#for aff in afflictions:
			#afflictions[aff].cured

(silent=True)
		#for record in data:
			#try:
				#aff = normalise_aff

(record)
				#if not

afflictions.has_key(aff):
					#continue
				#afflictions[aff].gained

()
			#except:
				#continue

	def char_defences_add(self, data):
		pass
		#ondef(data.get("name", None))

	def char_defences_remove(self, data):
		pass
		#for defence in data:
			#undef(defence)

	def char_defences_list(self, data):
		pass
		#update_defence_list([d["name"] for d in

data])

	def room_info(self, data):
		pass
			#me.last_room = me.room
		#roomdb[data["num"]] = Room(**data)
		#me.room = roomdb[data["num"]]
		#self.evm.fire(Event("check_moved_room"))

	def room_add_player(self, data):
		pass
		#try:
			#me.room.players.append(data

["name"].lower()) #do not convert to set you had a good

reason
		#except:
			#pass

	#convert the following to use list methods at

some point
	def room_remove_player(self, data):
		pass
		#if not me.room:
			#return
		#i = 0
		#name = data.lower()
		#while i < len(me.room.players):
			#if name == me.room.players[i]:
				#del me.room.players[i]
				#me.room.remove_blocker

(name)
				#return
			#i += 1

	def room_players(self, data):
		pass
		#try:
			#me.room.players = [p

["name"].lower() for p in data]
		#except:
			#pass

	def char_items_add(self, data):
		pass
		#id = data["item"]["id"]
		#name = data["item"]["name"]
		#attrib = data["item"]["attrib"] if

'attrib' in data["item"] else None
		#loc = data["location"]
		#if loc == "room":
			#me.room.items.add(id, name,

attrib)
		#elif loc == "inv":
			#me.inv.add(id, name, attrib)

	def char_items_remove(self, data):
		pass
		#item = int(data["item"]["id"])
		#loc = data["location"]
		#if loc == "room":
			#if item in me.room.items:
				#del(me.room.items[item])
		#elif loc == "inv":
			#if item in me.inv:
				#del(me.inv.items[item])

	def char_items_list(self, data):
		pass
		#loc = data["location"]
		#if loc == "room":
			#me.room.items.clear()
			#for item in data["items"]:
				#attrib = item['attrib']

if 'attrib' in item else None
				#me.room.items.add(int

(item['id']), item['name'], attrib)
		#elif loc == "inv":
			#me.inv.clear()
			#for item in data["items"]:
				#attrib = item['attrib']

if 'attrib' in item else None
				#me.inv.add(int(item

['id']), item['name'], attrib)

	def channel_start(self, data):
		return

	def channel_end(self, data):
		return

	def channel_text(self, data):
		pass
		#talker = data["talker"]
		#text = filter_ansi(data["text"])
		#channel = data["channel"]
		#if talker.lower() in allies and

channel.startswith("tell"):
			#handle_allied_tell(talker, text)

	def update(self, cmd, data):
		if cmd not in self.map.keys():
			alert("Unhandled gmcp command

'%s'" %cmd)
			return
		self.map[cmd](data)

gmcp = GmcpHandler()