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()