discord

import json
import math
import requests
import time

version = "1.6"

base = "https://discordapp.com/api"

class User:
    def __init__(self, user_json):
        self.id = user_json["id"]
        self.username = user_json["username"]
        self.discriminator = user_json["discriminator"]
        self.avatar = user_json["avatar"]
        try:
            self.verified = user_json["verified"]
            self.email = user_json["email"]
        except KeyError:
            pass
        try:
            self.bot = user_json["bot"]
        except KeyError:
            self.bot = False

class Attachment:
    def __init__(self, attach_json):
        self.id = attach_json["id"]
        self.filename = attach_json["filename"]
        self.size = attach_json["size"]
        self.url = attach_json["url"]
        self.proxy_url = attach_json["proxy_url"]
        try:
            self.height = attach_json["height"]
            self.width = attach_json["width"]
        except KeyError:
            pass

class Embed:
    def __init__(self, embed_json):
        self.title = embed_json["title"]
        self.type = embed_json["type"]
        self.description = embed_json["description"]
        self.url = embed_json["url"]
        if "thumbnail" in embed_json:
            self.thumbnail = embed_json["thumbnail"]
        if "provider" in embed_json:
            self.provider = embed_json["provider"]

class Message:
    def __init__(self, msg_json, session):
        self.session = session
        self.id = msg_json["id"]
        self.channel_id = msg_json["channel_id"]
        self.author = User(msg_json["author"])
        self.content = msg_json["content"]
        self.timestamp = msg_json["timestamp"]
        self.edited_timestamp = msg_json["edited_timestamp"]
        try:
            self.tts = msg_json["tts"]
        except KeyError:
            pass
        self.mention_everyone = msg_json["mention_everyone"]
        self.mentions = []
        for user_json in msg_json["mentions"]:
            self.mentions.append(User(user_json))
        self.attachments = []
        for attachment_json in msg_json["attachments"]:
            self.attachments.append(Attachment(attachment_json))
        self.embeds = []
        for embed_json in msg_json["embeds"]:
            self.embeds.append(Embed(embed_json))
        try:
            self.nonce = msg_json["nonce"]
        except KeyError:
            pass
    def reset(self, msg_json, session):
        self.session = session
        self.id = msg_json["id"]
        self.channel_id = msg_json["channel_id"]
        self.author = User(msg_json["author"])
        self.content = msg_json["content"]
        self.timestamp = msg_json["timestamp"]
        self.edited_timestamp = msg_json["edited_timestamp"]
        try:
            self.tts = msg_json["tts"]
        except KeyError:
            pass
        self.mention_everyone = msg_json["mention_everyone"]
        self.mentions = []
        for user_json in msg_json["mentions"]:
            self.mentions.append(User(user_json))
        self.attachments = []
        for attachment_json in msg_json["attachments"]:
            self.attachments.append(Attachment(attachment_json))
        self.embeds = []
        for embed_json in msg_json["embeds"]:
            self.embeds.append(Embed(embed_json))
        try:
            self.nonce = msg_json["nonce"]
        except KeyError:
            pass
    def edit(self, content):
        path = "/channels/" + str(self.channel_id) + "/messages/" + self.id
        response = self.session.patch(base + path, json = {"content": content})
        self.reset(json.loads(response.text), self.session)
        return True
    def delete(self):
        path = "/channels/" + str(self.channel_id) + "/messages/" + self.id
        response = self.session.delete(base + path)
        self.reset(json.loads(response.text), self.session)
        return True
    def ack():
        path = "/channels/" + str(self.channel_id) + "/messages/" + self.id + "/ack"
        response = self.session.post(base + path)
        if response.status_code == 204:
            return True
        else:
            return response.text

class Channel:
    def delete(self):
        path = "/channels/"
        response = self.session.delete(base + path + str(self.id))
        return json.loads(response.text)
    def get_messages(self, before = False, after = False, limit = 50):
        path = "/channels/" + str(self.id) + "/messages"
        extra = ""
        if before and after:
            return False
        elif before:
            extra = "before=" + before + "&"
        elif after:
            extra = "after=" + after + "&"
        response = self.session.get(base + path + "?" + extra + "limit=" + str(limit))
        messages = []
        for message in json.loads(response.text):
            messages.append(Message(message, self.session))
        return messages
    def send(self, content, nonce = False, tts = False):
        path = "/channels/" + str(self.id) + "/messages"
        data = {"content": content}
        if nonce:
            data["nonce"] = nonce
        if tts:
            data["tts"] = tts
        response = self.session.post(base + path, json = data)
        return Message(json.loads(response.text), self.session)
    def upload(self, file, content = "", nonce = False, tts = False):
        return False #TODO: Add file uploading
    def bulk_delete(self, messages):
        path = "/channels/" + self.id + "/messages/bulk\_delete"
        data = {}
        to_delete = []
        for entity in messages:
            try:
                to_delete.append(entity.id)
            except AttributeError:
                to_delete.append(str(entity))
        data["messages"] = to_delete
        response = self.session.post(base + path, json = data)
        if response.status_code == 204:
            return True
        else:
            return response.text
    def type(self):
        path = "/channels/" + self.id +  "/typing"
        response = self.session.post(base + path)
        if response.status_code == 204:
            return True
        else:
            return response.text

class PermissionOverwrite:
    def __init__(self, permo_json):
        self.id = permo_json["id"]
        self.type = permo_json["type"]
        self.allow = permo_json["allow"]
        self.deny = permo_json["deny"]

class Invite:
    def __init__(self, invite_json, session):
        self.code = invite_json["code"]
        self.guild = invite_json["guild"]
        self.channel = invite_json["channel"]
        self.xkcdpass = invite_json["xkcdpass"]
        self.session = session
    def reset(self, invite_json, session):
        self.code = invite_json["code"]
        self.guild = invite_json["guild"]
        self.channel = invite_json["channel"]
        self.xkcdpass = invite_json["xkcdpass"]
        self.session = session
    def delete(self):
        path = "/invites/" + self.code
        response = self.session.delete(base + path)
        self.reset(json.loads(response.text), self.session)
        return True

    def accept(self):
        path = "/invites/" + self.code
        response = self.session.post(base + path)
        self.reset(json.loads(response.text), self.session)
        return True

class InviteMetadata(Invite):
    def __init__(self, meta_json, session):
        super().__init__(meta_json, session)
        self.inviter = meta_json["inviter"]
        self.uses = meta_json["uses"]
        self.max_uses = meta_json["max_uses"]
        self.temporary = meta_json["temporary"]
        self.created_at = meta_json["created_at"]
        self.revoked = meta_json["revoked"]
        self.session = session

class GuildChannel(Channel):
    def __init__(self, gc_json, session):
        self.session = session
        self.id = gc_json["id"]
        self.guild_id = gc_json["guild_id"]
        self.name = gc_json["name"]
        self.type = gc_json["type"]
        self.position = gc_json["position"]
        self.is_private = gc_json["is_private"]
        self.channel_type = "guild"
        self.permission_overwrites = []
        for permo_json in gc_json["permission_overwrites"]:
            self.permission_overwrites.append(PermissionOverwrite(permo_json))
        if self.type == "text":
            self.topic = gc_json["topic"]
            self.last_message_id = gc_json["last_message_id"]
        elif self.type == "voice":
            self.bitrate = gc_json["bitrate"]
    def reset(self, gc_json, session):
        self.session = session
        self.id = gc_json["id"]
        self.guild_id = gc_json["guild_id"]
        self.name = gc_json["name"]
        self.type = gc_json["type"]
        self.position = gc_json["position"]
        self.is_private = gc_json["is_private"]
        self.channel_type = "guild"
        self.permission_overwrites = []
        for permo_json in gc_json["permission_overwrites"]:
            self.permission_overwrites.append(PermissionOverwrite(permo_json))
        if self.type == "text":
            self.topic = gc_json["topic"]
            self.last_message_id = gc_json["last_message_id"]
        elif self.type == "voice":
            self.bitrate = gc_json["bitrate"]
    def modify(self, name = False, position = False, topic = False, bitrate = False, user_limit = False):
        path = "/channels/"
        data = {}
        if name:
            data["name"] = name
        if position:
            data["position"] = int(position)
        if topic:
            data["topic"] = topic
        if bitrate:
            data["bitrate"] = int(bitrate)
        if user_limit:
            data["user_limit"] = int(user_limit)
        response = self.session.patch(base + path + str(self.id), data=data)
        if response.status_code == 400:
            return response.text
        else:
            self.reset(json.loads(response.text), self.session)
            return True

    def edit_permissions(self, id, allow, deny):
        path = "/channels/" + self.id + "/permissions/" + str(id)
        response = self.session.put(base + path, json = {"allow": allow, "deny": deny})
        if response.status_code == 204:
            return True
        else:
            return response.text

    def get_invites(self):
        path = "/channels/" + self.id + "/invites"
        response = self.session.get(base + path)
        invites = []
        for invite in json.loads(response.text):
            invites.append(InviteMetadata(invite, self.session))
        return invites

    def create_invite(self, duration = 86400, max_uses = 0, temporary = False, xkcdpass = False):
        path = "/channels/" + self.id + "/invites"
        data = {"duration": duration, "max_uses": max_uses, "temporary": temporary, "xkcdpass": xkcdpass}
        response = self.session.post(base + path, json = data)
        return Invite(json.loads(response.text), self.session)

    def delete_permission(self, id):
        path = "/channels/" + self.id + "/permissions/" + str(id)
        response = self.session.post(base + path)
        if response.status_code == 204:
            return True
        else:
            return response.text
    def modify_position(self, position):
        path = "/guilds/" + self.guild_id + "/channels"
        data = {"id": self.id, "position":  position}
        response = self.session.patch(base +  path, json = data)
        self.reset(json.loads(response.text), self.session)
        return True

class DM(Channel):
    def __init__(self, dm_json, session):
        self.session = session
        self.id = dm_json["id"]
        self.is_private = dm_json["is_private"]
        self.recipient = User(dm_json["recipient"])
        self.last_message_id = dm_json["last_message_id"]
        self.channel_type = "dm"

class VoiceState:
    def __init__(self, voice_json, session):
        self.session = session
        try:
            self.guild_id = voice_json["guild_id"]
        except KeyError:
            pass
        self.channel_id = voice_json["channel_id"]
        self.user_id = voice_json["user_id"]
        self.session_id = voice_json["session_id"]
        self.deaf = voice_json["deaf"]
        self.mute = voice_json["mute"]
        self.self_deaf = voice_json["self_deaf"]
        self.self_mute = voice_json["self_mute"]
        self.suppress = voice_json["suppress"]

class Role:
    def __init__(self, role_json, session, guild_id):
        self.session = session
        self.id = role_json["id"]
        self.name = role_json["name"]
        self.color = role_json["color"]
        self.hoist = role_json["hoist"]
        self.position = role_json["position"]
        self.permissions = role_json["permissions"]
        self.managed = role_json["managed"]
        self.mentionable = role_json["mentionable"]
        self.guild_id = guild_id
    def reset(self, role_json, session, guild_id):
        self.session = session
        self.id = role_json["id"]
        self.name = role_json["name"]
        self.color = role_json["color"]
        self.hoist = role_json["hoist"]
        self.position = role_json["position"]
        self.permissions = role_json["permissions"]
        self.managed = role_json["managed"]
        self.mentionable = role_json["mentionable"]
        self.guild_id = guild_id
    def modify(self, name = None, permissions = None, position = None, color = None, hoist = None, mentionable = None):
        path = "/guilds/" + self.guild_id + "/roles/" + self.id
        if name is None:
            name = self.name
        if permissions is None:
            permissions = self.permissions
        if position is None:
            position = self.position
        if color is None:
            color = self.color
        if hoist is None:
            hoist = self.hoist
        if mentionable is None:
            mentionable = self.mentionable
        data = {"name" : name, "permissions": permissions, "position": position, "color": color, "hoist": hoist, "mentionable": mentionable}
        response = self.session.patch(base + path, json = data)
        self.reset(json.loads(response.text), self.session, self.guild_id)
        return True

    def delete(self):
        path = "/guilds/" + self.guild_id + "/roles/" + self.id
        response = self.session.delete(base + path)
        self.reset_(json.loads(response.text), self.session, self.guild_id)
        return True

class Emoji:
    def __init__(self, emoji_json, session):
        self.session = session
        self.id = role_json["id"]
        self.name = role_json["name"]
        self.roles = []
        for role in role_json["roles"]:
            self.roles.append(Role(role, self.session, self.id))
        self.require_colons = role_json["require_colons"]
        self.managed = role_json["managed"]

class GuildMember:
    def __init__(self, gm_json, session, guild_id):
        self.session = session
        self.user = User(gm_json["user"])
        try:
            self.nick = gm_json["nick"]
        except KeyError:
            pass
        self.roles = gm_json["roles"]
        self.joined_at = gm_json["joined_at"]
        self.deaf = gm_json["deaf"]
        self.mute = gm_json["mute"]
        self.guild_id = guild_id
    def reset(self, gm_json, session, guild_id):
        self.session = session
        self.user = User(gm_json["user"])
        try:
            self.nick = gm_json["nick"]
        except KeyError:
            pass
        self.roles = gm_json["roles"]
        self.joined_at = gm_json["joined_at"]
        self.deaf = gm_json["deaf"]
        self.mute = gm_json["mute"]
        self.guild_id = guild_id
    def modify(self, nick = False, roles = False, mute = False, deaf = False, channel_id = False):
        path = "/guilds/" + self.guild_id + "/members/" + self.user.id
        data = {}
        if nick:
            data["nick"] = nick
        if roles:
            data["roles"] = roles
        if mute:
            data["mute"] = mute
        if deaf:
            data["deaf"] = deaf
        if channel_id:
            data["channel_id"] = channel_id
        response = self.session.patch(base + path, json = data)
        try:
            json.loads(response.text)
            return False
        except ValueError:
            return True

    def remove(self):
        path = "/guilds/" + self.guild_id + "/members/" + self.user.id
        response = self.session.delete(base + path)
        if response.status_code == 204:
            return True
        else:
            return response.text

    def ban(self, delete=0):
        path = "/guilds/" + self.guild_id + "/bans/" + self.id
        data = {"delete-message-days": delete}
        response = self.session.put(base + path, json = data)
        if response.status_code == 204:
            return True
        else:
            return response.text

    def unban(self):
        path = "/guilds/" + self.guild_id + "/bans/" + self.id
        response = self.session.delete(base + path)
        if response.status_code == 204:
            return True
        else:
            return response.text

class Integration:
    def __init__(self, in_json, session, guild_id):
        self.session = session
        self.guild_id = guild_id
        self.id = in_json["id"]
        self.name = in_json["name"]
        self.type = in_json["type"]
        self.enabled = in_json["enabled"]
        self.syncing = in_json["syncing"]
        self.role_id = in_json["role_id"]
        self.expire_behavior = in_json["expire_behavior"]
        self.expire_grace_period = in_json["expire_grace_period"]
        self.user = User(in_json["user"])
        self.account = in_json["account"]
        self.synced_at = in_json["synced_at"]

    def modify(self, expire_behavior, expire_grace_period, enable_emoticons = False):
        path = "/guilds/" + self.guild_id + "/integrations/" + self.id
        data = {"expire_behavior": expire_behavior, "expire_grace_period": expire_grace_period}
        if enable_emoticons:
            data["enable_emoticons"] = enable_emoticons
        response = self.session.patch(base + path, json = data)
        if response.status_code == 204:
            return True
        else:
            return response.text

    def delete(self):
        path = "/guilds/" + self.guild_id + "/integrations/" + self.id
        response = self.session.delete(base + path)
        if response.status_code == 204:
            return True
        else:
            return response.text

    def sync(self):
        path = "/guilds/" + self.guild_id + "/integrations/" + self.id + "/sync"
        response = self.session.post(base + path)
        if response.status_code == 204:
            return True
        else:
            return response.text

class GuildEmbed:
    def __init__(self, ge_json):
        self.enabled = ge_json["enabled"]
        self.channel_id = ge_json["channel_id"]

class Guild:
    def __init__(self, guild_json, session):
        self.session = session
        self.id = guild_json["id"]
        self.name = guild_json["name"]
        self.icon = guild_json["icon"]
        self.splash = guild_json["splash"]
        self.owner_id = guild_json["owner_id"]
        self.region = guild_json["region"]
        self.afk_channel_id = guild_json["afk_channel_id"]
        self.afk_timeout = guild_json["afk_timeout"]
        self.embed_enabled = guild_json["embed_enabled"]
        self.embed_channel_id = guild_json["embed_channel_id"]
        self.verification_level = guild_json["verification_level"]
        self.voice_states = []
        try:
            for voice_state in guild_json["voice_states"]:
                self.voice_states.append(VoiceState(voice_state))
        except KeyError:
            pass
        self.roles = []
        for role in guild_json["roles"]:
            self.roles.append(Role(role, self.session, self.id))
        self.emojis = []
        for emoji in guild_json["emojis"]:
            self.emojis.append(Emoji(emoji))
        self.features = guild_json["features"]
    def reset(self, guild_json, session):
        self.session = session
        self.id = guild_json["id"]
        self.name = guild_json["name"]
        self.icon = guild_json["icon"]
        self.splash = guild_json["splash"]
        self.owner_id = guild_json["owner_id"]
        self.region = guild_json["region"]
        self.afk_channel_id = guild_json["afk_channel_id"]
        self.afk_timeout = guild_json["afk_timeout"]
        self.embed_enabled = guild_json["embed_enabled"]
        self.embed_channel_id = guild_json["embed_channel_id"]
        self.verification_level = guild_json["verification_level"]
        self.voice_states = []
        try:
            for voice_state in guild_json["voice_states"]:
                self.voice_states.append(VoiceState(voice_state))
        except KeyError:
            pass
        self.roles = []
        for role in guild_json["roles"]:
            self.roles.append(Role(role, self.session, self.id))
        self.emojis = []
        for emoji in guild_json["emojis"]:
            self.emojis.append(Emoji(emoji))
        self.features = guild_json["features"]
    def modify(self, name = False, region = False, verification_level = False, afk_channel_id = False, afk_timeout = False, icon = False, owner_id = False, splash = False):
        path = "/guilds/" + self.id
        data = {}
        if name:
            data["name"] = name
        if region:
            data["region"] = region
        if verification_level:
            data["verification_level"] = verification_level
        if afk_channel_id:
            data["afk_channel_id"] = afk_channel_id
        if afk_timeout:
            data["afk_timeout"] = afk_timeout
        if icon:
            data["icon"] = icon
        if owner_id:
            data["owner_id"] = owner_id
        if splash:
            data["splash"] = splash
        response = self.session.patch(base + path, json = data)
        self.reset(json.loads(response.text), self.session)
        return True

    def delete(self):
        path = "/guilds/" + self.id
        response = self.session.delete(base + path)
        self.reset(json.loads(response.text), self.session)
        return True

    def get_channels(self):
        path = "/guilds/" + self.id + "/channels"
        response = self.session.get(base + path)
        guild_channels = []
        for guild_channel in json.loads(response.text):
            guild_channels.append(GuildChannel(guild_channel, self.session))
        return guild_channels

    def create_channel(self, name, type, bitrate = 64000):
        path = "/guilds/" + self.id + "/channels"
        data = {"name": name, "type": type, "bitrate": bitrate}
        response = self.session.post(base + path, json = data)
        return GuildChannel(json.loads(response.text), self.session)

    def leave_guild(self):
        path = "/users/@me/guilds/"
        response = self.session.delete(base + path + self.id)
        if response.status_code == 204:
            return True
        else:
            return response.text

    def get_member(self, id):
        path = "/guilds/" + self.id + "/members/" + str(id)
        response = self.session.get(base + path)
        return GuildMember(json.loads(response.text, self.session, self.id))

    def list_members(self, limit=1, offset=0):
        path = "/guilds/" + self.id + "/members"
        response = self.session.get(base + path + "?limit=" + str(limit) + "&offset=" + str(offset))
        guild_members_raw = json.loads(response.text)
        guild_members = []
        for guild_member in guild_members_raw:
            guild_members.append(GuildMember(guild_member, self.session, self.id))
        return guild_members

    def get_bans(self):
        path = "/guilds/" + self.id + "/bans"
        response = self.session.get(base + path)
        bans = []
        for ban in json.loads(response.text):
            bans.append(User(ban))
        return Bans

    def ban(self, id, delete=0):
        path = "/guilds/" + self.id + "/bans/" + str(id)
        data = {"delete-message-days": delete}
        response = self.session.put(base + path, json = data)
        if response.status_code == 204:
            return True
        else:
            return response.text

    def unban(self, id):
        path = "/guilds/" + self.id + "/bans/" + str(id)
        response = self.session.delete(base + path)
        if response.status_code == 204:
            return True
        else:
            return response.text

    def get_roles(self):
        path = "/guilds/" + self.id + "/roles"
        response = self.session.get(base + path)
        roles = []
        for role in json.loads(response.text):
            roles.append(Role(role, self.session, self.id))
        return roles

    def create_role(self):
        path = "/guilds/" + self.id + "/roles"
        response = self.session.post(base + path)
        return Role(json.loads(response.text), self.session, self.id)

    def modify_role(self, bulk):
        path = "/guilds/" + self.id + "/roles"
        data = bulk
        response = self.session.patch(base + path, json = data)
        return response.text

    def get_prune(self, days):
        path = "/guilds/" + self.id + "/prune"
        response = self.session.get(base + path + "?days=" + str(days))
        return json.loads(response.text)["pruned"]

    def begin_prune(self, days):
        path = "/guilds/" + self.id + "/prune"
        data = {"days": int(days)}
        response = self.session.post(base + path, json = data)
        return json.loads(response.text)["pruned"]

    def get_voice_regions(self):
        path = "/guilds/" + self.id + "/regions"
        response = self.session.get(base + path)
        return json.loads(response.text)

    def get_invites(self):
        path = "/guilds/" + self.id + "/invites"
        response = self.session.get(base + path)
        invites = []
        for invite in json.loads(response.text):
            invites.append(InviteMetadata(invite, self.session))

    def get_integrations(self):
        path = "/guilds/" + self.id + "/integrations"
        response = self.session.get(base + path)
        integrations = []
        for integration in json.loads(response.text):
            integrations.append(Integration(integration, self.session, self.id))
        return integrations

    def create_integration(self, type, id):
        path = "/guilds/" + self.id + "/integrations"
        data = {"type": type, "id": id}
        response = self.session.post(base + path, json = data)
        if response.status_code == 204:
            return True
        else:
            return response.text

    def get_embed(self):
        path = "/guilds/" + self.id + "/embed"
        response = self.session.get(base + path)
        return GuildEmbed(json.loads(response.text))

    def modify_embed(self, enabled = "Not set", channel_id = False):
        path = "/guilds/" + self.id + "/embed"
        data = {}
        if enabled != "Not set":
            data["enabled"] = enabled
        if channel_id:
            data["channel_id"] = channel_id
        response = self.session.patch(base + path, json = data)
        return GuildEmbed(json.loads(response.text))

    def nick(self, nickname):
        path = "/guilds/" + self.id + "/members/@me/nick"
        data = {"nick": nickname}
        response = self.session.patch(base + path, json = data)
        if response.status_code == 200:
            return json.loads(response.text)
        else:
            return response.text

class Discord:

    def __init__(self, authorization, bot = False, user_agent = "Default Discord-py UserAgent"):
        self.session = requests.Session()
        self.auth = authorization
        self.is_bot = bot
        self.session.headers.update({"Authorization": self.auth, "User-Agent": user_agent})

    def status(self, message):
            path = "/track"
            response = self.session.post(base + path, json = {"event": "Launch Game", "properties": {"Game": message}})
            if response.status_code == 204:
                return True
            else:
                return response.text

    def search_users(self, query, limit=25):
        path = "/users"
        response = self.session.get(base + path + "?q=" + query + "&limit=" + str(int(limit)))
        users = []
        for user in json.loads(response.text):
            users.append(User(user))
        return users

    def get_current_user(self, debug = False):
        path = "/users/@me"
        response = self.session.get(base + path)
        if debug == False:
            return User(json.loads(response.text))
        else:
            return response.text

    def get_user(self, user_id):
        path = "/users"
        response = self.session.get(base + path + "/" + user_id)
        return User(json.loads(response.text))

    def modify_user(self, username, avatar = False, new_password = False, email = "", password = ""):
        path = "/users/@me"
        data = {"username": username}
        if avatar:
            data["avatar"] = avatar
        if not self.is_bot:
            data["password"] = password
            data["email"] = email
            if new_password:
                data["new_password"] = new_password
        response = self.session.patch(base + path, json = data)
        me = json.loads(response.text)
        if self.is_bot == False and new_password:
            self.auth = me["token"]
            self.session.headers.update({"Authorization": self.auth})
        return me

    def get_guilds(self):
        path = "/users/@me/guilds"
        response = self.session.get(base + path)
        user_guilds = []
        for user_guild in json.loads(response.text):
            user_guilds.append(user_guild) #It's possible we'll make a User Guild Object
        return user_guilds

    def leave_guild(self, guild_id):
        path = "/users/@me/guilds/"
        response = self.session.delete(base + path + str(guild_id))
        if response.status_code == 204:
            return True
        else:
            return response.text

    def get_dms(self):
        path = "/users/@me/channels"
        response = self.session.get(base + path)
        dms = json.loads(response.text)
        dm_list = []
        for dm_channel in dms:
            dm_list.append(DM(dm_channel, self.session))
        return dm_list

    def create_dm(self, recipient):
        path = "/users/@me/channels"
        response = self.session.post(base + path, json = {"recipient_id": recipient})
        return DM(json.loads(response.text), self.session)

    def get_connections(self):
        return False ##TODO: Do something with this?

    def get_channel(self, channel_id):
        path = "/channels/"
        response = self.session.get(base + path + str(channel_id))
        channel = json.loads(response.text)
        if channel["is_private"]:
            return DM(channel, self.session)
        else:
            return GuildChannel(channel, self.session)

    def get_guild(self, guild_id):
        path = "/guilds/"
        response = self.session.get(base + path + str(guild_id))
        guild = json.loads(response.text)
        return Guild(guild, self.session)

    def create_guild(self, name, region, icon):
        path = "/guilds"
        data = {"name": name, "region": region, "icon": icon}
        response = self.session.post(base + path, json = data)
        return Guild(json.loads(response.text), self.session)

    def accept_invite(self, id):
        path = "/invites/" + str(id)
        response = self.session.post(base + path)
        return Invite(json.loads(response.text), self.session)

    def logout(self, provider = "apns", token = "null"):
        path = "/auth/logout"
        data = {"provider": provider, "token": token}
        response = self.session.post(base + path, json = data)
        if response.status_code == 204:
            return True
        else:
            return response.text

def login(email, password):
    path = "/auth/login"
    data = {"email": email, "password": password}
    response = requests.post(base + path, json = data)
    if response.status_code == 200:
        return json.loads(response.text)["token"]
    else:
        resp = json.loads(response.text)
        try:
            if resp["email"][0] == "Email does not exist.":
                return "Nonexistant Email"
        except KeyError:
            try:
                if resp["password"][0] == "Password does not match.":
                    return "Incorrect password."
            except KeyError:
                return response
        return response