import json
import string

from funcs import logThis

class SwChar():
    def __init__(self, bot):
        self.bot = bot

    def getCharName(self, user : str):
        logThis("Getting name for "+self.bot.funcs.getName(user)+"'s character")
        userCharacter = self.bot.database["swcharacters"].find_one({"_id":user})

        if user != None:
            logThis("Name is "+userCharacter["Name"])
            return userCharacter["Name"]
        else:
            logThis("Just using "+self.bot.funcs.getName(user))
            return self.bot.funcs.getName(user)

    def setUpDict(self, cmd : dict):
        logThis("Setting up a dictionary in a nice way")
        if bool(cmd):
            keys = list(cmd)
            values = list(cmd.values())
            result = ""
            if isinstance(values[0],dict):
                return ", ".join(values)
            else:
                for x, key in enumerate(keys):
                    if type(key) is list:
                        if x%3 != 2:
                            result += "**" + key + "**" + ": " + ", ".join(values[x]) + " "
                        else:
                            result += "**" + key + "**" + ": " + ", ".join(values[x]) + "\n"
                    else:
                        if x%3 != 2:
                            result += "**" + key + "**" + ": " + str(values[x]) + " "
                        else:
                            result += "**" + key + "**" + ": " + str(values[x]) + "\n"
                logThis("Returning a dictionary, but well formatted")
                return result
        else:
            logThis("Couldn't find anything")
            return "There doesn't seem to be anything here..."

    def lookUp(self, data : dict, key : str, cmd : str = ""):
        if cmd == " ":
            cmd = ""
        elif cmd != "":
            while cmd[0] == " ":
                cmd = cmd[1:]
                if cmd == "":
                    break

        logThis("Looking up "+key)
        if key in data:
            logThis(key+" exists")
            if cmd == "":
                if type(data[key]) is dict and key != "Weapons":
                    return self.setUpDict(data[key])
                elif key == "Weapons":
                    logThis("Does this even get used? I'm too scared to delete it")
                    if bool(data[key]):
                        logThis("Found "+(", ".join(list(data[key]))))
                        return ", ".join(list(data[key]))
                    else:
                        logThis("There is nothing here")
                        return "There doesn't seem to be anything here..."
                else:
                    if str(data[key]) != "":
                        logThis("Returning "+str(data[key]))
                        return data[key]
                    else:
                        logThis("There was nothing there")
                        return "There doesn't seem to be anything here"
            elif cmd[0] == '+':
                logThis("Trying to add to "+key)
                try:
                    cmd = cmd[1:]
                    while cmd[0] == ' ':
                        cmd = cmd[1:]
                except:
                    logThis("Yeah, that fucked up")
                    return "Can't do that"

                if type(data[key]) is int:
                    try:
                        newValue = data[key] + int(cmd)
                        data[key] = newValue
                        logThis("Added "+cmd+" to "+key)
                        return data
                    except:
                        logThis("Couldn't add "+cmd+" to "+key)
                        return "Can't add that"
                elif type(data[key]) is list:
                        try:
                            data[key].append(cmd)
                            logThis("Added "+cmd+" to "+key)
                            return data
                        except:
                            logThis("Couldn't add "+cmd+" to "+key)
                            return "Can't add that"
                else:
                    logThis("Yeah, I can't add that to "+key)
                    return "Can't add that"

            elif cmd[0] == '-':
                logThis("Trying to remove/subtract from "+key)
                try:
                    cmd = cmd[1:]
                    while cmd[0] == ' ':
                        cmd = cmd[1:]
                except:
                    logThis("Yeah, that fucked up")
                    return "Can't do that"

                if type(data[key]) is int:
                    try:
                        newValue = data[key] - int(cmd)
                        data[key] = newValue
                        logThis("Subtracted "+cmd+" from "+key)
                        return data
                    except:
                        logThis("Couldn't subtract "+cmd+" from "+key)
                        return "Can't remove that"
                elif type(data[key]) is list:
                        try:
                            data[key].remove(cmd)
                            logThis("Removed "+cmd+" from "+key)
                            return data
                        except:
                            logThis("Couldn't remove "+cmd+" from "+key)
                            return "Can't remove that"
                else:
                    logThis("Yeah, I can't remove/subtract that from "+key)
                    return "Can't remove that"
            else:
                while cmd[0] == ' ':
                    cmd = cmd[1:]

                if type(data[key]) is dict:
                    newKey = cmd.split(" ")[0]
                    cmd = cmd[len(newKey):]
                    if cmd != "":
                        while cmd[0] == " ":
                            cmd = cmd[1:]
                            if cmd == "":
                                break
                    logThis("Looking up "+newKey+" in "+key)
                    lookUpResult = self.lookUp(data[key],newKey,cmd)
                    if type(lookUpResult) is dict:
                        data[key] = lookUpResult
                        return data
                    else:
                        return lookUpResult
                elif type(data[key]) != list:
                    logThis("Trying to change "+key+" to "+cmd)
                    try:
                        cmd = type(data[key])(cmd)
                        data[key] = cmd
                        logThis("Did that")
                        return data
                    except:
                        logThis("No. That did not work")
                        return "Wrong data type"
                else:
                    logThis("Yeah, that didn't work")
                    return "Wrong data type"
        else:
            logThis("Couldn't find "+key)
            logThis("Testing to see if it's a multi-word key")
            cmd = key + " " + cmd
            words = cmd.split(" ")
            search = ""
            i = 0
            while search not in data:
                try:
                    search += " " + words[i]
                    i += 1
                except:
                    logThis("It wasn't. "+search+" doesn't exist")
                    return search + " doesn't exist"
                if search[0] == " ":
                    search = search[1:]
            logThis("Yeah! Did that! The key was "+search)

            cmd = cmd[len(search):]
            if cmd != "":
                while cmd[0] == " ":
                    cmd = cmd[1:]
                    if cmd == "":
                        break

            if cmd == "":
                logThis("Returning "+search)
                return self.setUpDict(data[search])
            else:
                newKey = cmd.split(" ")[0]
                cmd = cmd[len(newKey):]
                if cmd != "":
                    while cmd[0] == " ":
                        cmd = cmd[1:]
                        if cmd == "":
                            break
                lookUpResult = self.lookUp(data[search],newKey,cmd)
                if type(lookUpResult) is dict:
                    data[search] = lookUpResult
                    return data
                else:
                    return lookUpResult

    def characterSheet(self,character : dict):
        logThis("Setting up a character sheet for "+character["Name"])
        divider = "--------------------\n"
        name = character["Name"]
        textf = ""
        if character["Force-rating"] != 0:
            textf = "\n**Force Rating**: "+str(character["Force-rating"])

        text1 = "**Species**: "+character["Species"]+"\n**Career**: "+character["Career"]+"\n**Specialization Trees**: "+", ".join(character["Specialization-trees"])+textf+"\n**Soak**: "+str(character["Soak"])
        text2 = "\n\n**Wounds**: "+str(character["Wounds"])+"/"+str(character["Wound-threshold"])+"\n**Strain**: "+str(character["Strain"])+"/"+str(character["Strain-threshold"])
        text3 = self.setUpDict(character["Characteristics"])
        text4 = self.setUpDict(character["Skills"])
        text5 = ""
        text6 = ""
        text7 = ""
        text8 = ""

        if bool(character["Talents"]):
            text5 = "**Talents**: "+", ".join(list(character["Talents"]))+"\n\n"

        if bool(character["Force-powers"]):
            text6 = "**Force Powers**: "+", ".join(list(character["Force-powers"]))+"\n\n"

        text7 = "**Equipment**: "+", ".join(character["Equipment"])+"\n**Credits**: "+str(character["Credits"])+"\n**Weapons**: "+", ".join(list(character["Weapons"]))+"\n"+divider

        if bool(character["Obligations"]):
            text8 = "**Obligations**: "+",".join(list(character["Obligations"]))

        return name, text1+text2+"\n\n"+text3+divider+text4+"\n"+divider+text5+text6+text7+text8

    def charData(self,user : str,cmd : str):
        userCharacter = self.bot.database["swcharacters"].find_one({"_id":user})

        key = string.capwords(cmd.split(" ")[0])
        cmd = cmd[len(key):]
        if cmd == " ":
            cmd = ""
        elif cmd != "":
            while cmd[0] == " ":
                cmd = cmd[1:]
                if cmd == "":
                    break

        logThis("Looking for "+self.bot.funcs.getName(user)+"'s character")
        if userCharacter != None:
            logThis("Foundt it! Looking for "+key+" in the data")
            if key in userCharacter:
                logThis("Found it!")
                if type(userCharacter[key]) is dict:
                    logThis("It's a dictionary!")
                    if cmd == "":
                        logThis("Retrieving data")
                        if key == "Weapons":
                            if bool(userCharacter[key]):
                                logThis("Returning a list of weapons")
                                return ", ".join(list(userCharacter[key]))
                            else:
                                logThis("The character doesn't have any weapons. Which is probably for the best. Like, who just walks around with weapons? (error code 941)")
                                return "There doesn't seem to be anything there... (error code 941)"
                        else:
                            return self.setUpDict(userCharacter[key])
                    elif cmd[0] == "+":
                        logThis("Gonna add something!!!")
                        try:
                            cmd = cmd[1:]
                            while cmd[0] == ' ':
                                cmd = cmd[1:]
                        except:
                            logThis("Nope. That didn't happen (error code 942)")
                            return "Can't do that (error code 942)"

                        if (key == "Talents" or key == "Force-powers") and "," in cmd:
                            cmd = cmd.split(",")
                            while cmd[1][0] == " ":
                                cmd[1] = cmd[1][1:]
                            logThis("Adding "+cmd[0]+" to "+key)
                            self.bot.database["swcharacters"].update_one({"_id":user},
                                {"$set": {key+"."+cmd[0] : cmd[1]}})
                            return cmd[0]+" added to "+key+" for " + userCharacter["Name"]

                        elif key == "Obligations" and "," in cmd:
                            cmd = cmd.split(",")
                            while cmd[1][0] == " ":
                                cmd[1] = cmd[1][1:]
                            logThis("Adding "+cmd[0]+" to "+key)
                            try:
                                self.bot.database["swcharacters"].update_one({"_id":user},
                                    {"$set": {key+"."+cmd[0] : int(cmd[1])}})
                            except:
                                logThis("Fucked that up (error code 949)")
                                return "Wrong data type (error code 949)"
                            return cmd[0]+" added to "+key+" for " + userCharacter["Name"]

                        elif key == "Weapons":
                            with open("resources/starWars/swtemplates.json", "r") as f:
                                templates = json.load(f)
                            newWeapon = templates["Weapon"]
                            logThis("Adding "+cmd+" to "+key)
                            self.bot.database["swcharacters"].update_one({"_id":user},
                                {"$set": {key+"."+cmd : newWeapon}})

                            return cmd+" added to weapons for " + userCharacter["Name"]

                        else:
                            logThis("That's not happening (error code 947d)")
                            return "Can't add that (error code 947d)"

                    elif cmd[0] == "-":
                        logThis("Gonna subtract/remove something")
                        try:
                            cmd = cmd[1:]
                            while cmd[0] == ' ':
                                cmd = cmd[1:]
                        except:
                            logThis("AAAAAAAAAAAA  (error code 948)")
                            return "Can't do that  (error code 948)"

                        if key == "Talents" or key == "Force-powers" or key == "Weapons" or key == "Obligations":
                            logThis("Trying to remove "+cmd+" from "+key)
                            if cmd in userCharacter[key]:
                                self.bot.database["swcharacters"].update_one({"_id":user},
                                    {"$unset": {cmd}})
                                logThis("I did that")
                                return cmd+" removed from "+key+" from "+userCharacter["Name"]
                            else:
                                logThis("Welp. I fucked that up (error code 946e)")
                                return "Can't remove that (error code 946e)"
                        else:
                            logThis("Urgh! (error code 946d)")
                            return "Can't remove that (error code 946d)"

                    else:
                        logThis("Looking up "+cmd+" in "+key)
                        if key == "Talents" or key == "Force-powers":
                            newKey = cmd
                            newcmd = ""
                        else:
                            newKey = string.capwords(cmd.split(" ")[0])
                            newcmd = cmd[len(newKey):]

                        lookUpResult = self.lookUp(userCharacter[key],newKey,newcmd)

                        if type(lookUpResult) is dict:
                            self.bot.database["swcharacters"].update_one({"_id":user},
                                {"$set": {key : lookUpResult}})
                            return "Changed " + userCharacter["Name"] + "'s " + key
                        else:
                            return lookUpResult
                else:
                    if cmd == "":
                        logThis("Retrieving data")
                        if type(userCharacter[key]) is list:
                            return key+":\n"+", ".join(userCharacter[key])
                        else:
                            return userCharacter[key]
                    elif cmd[0] == '+':
                        logThis("Adding")
                        try:
                            cmd = cmd[1:]
                            while cmd[0] == ' ':
                                cmd = cmd[1:]
                        except:
                            logThis("Error message (error code 948)")
                            return "Can't do that (error code 948)"

                        if type(userCharacter[key]) is int:
                            try:
                                logThis("Adding "+cmd+" to "+key)
                                self.bot.database["swcharacters"].update_one({"_id":user},
                                    {"$inc": {key : int(cmd)}})
                                return "Added " + cmd + " to " + userCharacter["Name"] + "'s " + key
                            except:
                                logThis("BITCH SANDWICH (error code 947c)")
                                return "Can't add that (error code 947c)"
                        elif type(userCharacter[key]) is list:
                            try:
                                logThis("Adding "+cmd+" to "+key)
                                self.bot.database["swcharacters"].update_one({"_id":user},
                                    {"$push": {key : cmd}})
                                return "Added " + cmd + " to " + userCharacter["Name"] + "'s " + key
                            except:
                                logThis("tstststststs (error code 947b)")
                                return "Can't add that (error code 947b)"
                        else:
                            logThis("Help (error code 947a)")
                            return "Can't add that (error code 947a)"
                    elif cmd[0] == '-':
                        logThis("Removing/subtracting")
                        try:
                            cmd = cmd[1:]
                            while cmd[0] == ' ':
                                cmd = cmd[1:]
                        except:
                            logThis("lalalala  (error code 948)")
                            return "Can't do that (error code 948)"

                        if type(userCharacter[key]) is int:
                            try:
                                logThis("Subtracting "+cmd+" from "+key)
                                self.bot.database["swcharacters"].update_one({"_id":user},
                                    {"$inc": {key : -int(cmd)}})
                                return "Subtracted " + cmd + " from " + userCharacter["Name"] + "'s " + key
                            except:
                                logThis("Tried it. Didn't want to (error code 946c)")
                                return "Can't remove that (error code 946c)"
                        elif type(userCharacter[key]) is list:
                            try:
                                logThis("removing "+cmd+" from "+key)
                                try:
                                    self.bot.database["swcharacters"].update_one({"_id":user},
                                        {"$pull": {key : cmd}})
                                except:
                                    logThis("They can only remove stuff that's actually in the list")
                                    return "Not in list (error code 944b)"
                                return "Removed " + cmd + " from " + userCharacter["Name"] + "'s " + key
                            except:
                                logThis("nah (error code 946b)")
                                return "Can't remove that (error code 946b)"
                        else:
                            logThis("nyope (error code 946a)")
                            return "Can't remove that (error code 946a)"
                    else:
                        logThis("Changing "+key+" to "+cmd)
                        if type(userCharacter[key]) is int:
                            try:
                                self.bot.database["swcharacters"].update_one({"_id":user},
                                    {"$set": {key : int(cmd)}})
                            except:
                                logThis("I don't wanna tho (error code 945b)")
                                return "Can't do that (error code 945b)"
                        elif type(userCharacter[key]) is str:
                            self.bot.database["swcharacters"].update_one({"_id":user},
                                {"$set": {key : cmd}})
                        else:
                            logThis("I don't wanna tho (error code 945a)")
                            return "Can't do that (error code 945a)"
                        return "Changed " + userCharacter["Name"] + "'s " + key +" to " + cmd
            else:
                logThis(key+" isn't in there (error code 944)")
                return "Couldn't find that data. Are you sure you spelled it correctly? (error code 944)"
        else:
            logThis(user+" doesn't have a character (error code 943)")
            return "You don't have a character. You can make one with !swchar (error code 943)"

    def replaceSpaces(self,cmd : str):
        withSpaces = ["Specialization Trees","Wound Threshold","Strain Threshold","Defense - Ranged","Defense - Melee","Force Rating","Core Worlds","Outer Rim","Piloting - Planetary","Piloting - Space","Ranged - Heavy","Ranged - Light","Lightsaber Characteristic","Critical Injuries","Force Powers"]
        withoutSpaces = ["Specialization-trees","Wound-threshold","Strain-threshold","Defense-ranged","Defense-melee","Force-rating","Core-worlds","Outer-rim","Piloting-planetary","Piloting-space","Ranged-heavy","Ranged-light","Lightsaber-characteristic","Critical-injuries","Force-powers"]

        for x, value in enumerate(withoutSpaces):
            cmd = cmd.replace(withSpaces[x],value)

        return cmd

    def replaceWithSpaces(self,cmd : str):
        withSpaces = ["Specialization Trees","Wound Threshold","Strain Threshold","Defense - Ranged","Defense - Melee","Force Rating","Core Worlds","Outer Rim","Piloting - Planetary","Piloting - Space","Ranged - Heavy","Ranged - light","Lightsaber Characteristic","Critical Injuries","Force Powers"]
        withoutSpaces = ["Specialization-trees","Wound-threshold","Strain-threshold","Defense-ranged","Defense-melee","Force-rating","Core-worlds","Outer-rim","Piloting-planetary","Piloting-space","Ranged-heavy","Ranged-light","Lightsaber-characteristic","Critical-injuries","Force-powers"]

        for x, value in enumerate(withoutSpaces):
            cmd = cmd.replace(value,withSpaces[x])

        return cmd

    def parseChar(self,user : str, cmd : str):

        cmd = self.replaceSpaces(cmd)

        userCharacter = self.bot.database["swcharacters"].find_one({"_id":user})

        if cmd == " ":
            cmd = ""
        elif cmd != "":
            while cmd[0] == " ":
                cmd = cmd[1:]
                if cmd == "":
                    break


        if cmd == "":
            if userCharacter != None:
                text1, text2 = self.characterSheet(userCharacter)
                return text1, self.replaceWithSpaces(text2)
            else:
                logThis("Makin' a character for "+self.bot.funcs.getName(user))
                with open("resources/starWars/swtemplates.json", "r") as f:
                    templates = json.load(f)
                newChar = templates["Character"]
                print("yeet")
                newChar["_id"] = user
                print("yeet")
                self.bot.database["swcharacters"].insert_one(newChar)
                print("yeet")
                return "", "Character for " + self.bot.funcs.getName(user) + " created"
        else:
            if cmd == "Purge":
                logThis("Deleting "+self.bot.funcs.getName(user)+"'s character")
                self.bot.database["swcharacters"].remove_one({newChar})
                return "", "Character for " + self.bot.funcs.getName(user) + " deleted"
            else:
                return "", self.replaceWithSpaces(str(self.charData(user,cmd)))

    def lightsaberChar(self,user : str):
        userCharacter = self.bot.database["swcharacters"].find_one({"_id":user})

        if userCharacter != None:
            return userCharacter["Lightsaber-characteristic"]

    def userHasChar(self,user : str):
        userCharacter = self.bot.database["swcharacters"].find_one({"_id":user})

        return userCharacter != None