from typing import List, Dict, Union
from datetime import datetime


class Embed:
    def __init__(
            self,
            color: str,
            title: str,
            siteName: str,
            description: str,
            **kwargs
    ):
        """Embed object used for checking embeds

        Args:
            color (str): String of the embed's color
            title (str): String of the embed's title
            siteName (str): String of the embed's site name
            description (str): String of the embed's description
        """

        self.color = color
        self.title = title
        self.siteName = siteName
        self.description = description
        self.__dict__.update(kwargs)


class File:
    def __init__(
            self,
            createdAt: datetime,
            id: int,
            mimetype: str,
            views: int,
            name: str,
            size: int,
            favorite: bool,
            originalName: str = None,
            url: str = None,
            maxViews: int = None,
            expiredAt: Union[datetime, None] = None,
            thumbnail: str = None,
            folderId: int = None,
            **kwargs
            ):
        """File object used for uploading files to Zipline

        Args:
            createdAt (datetime.datetime): Datetime object of when the file was created
            id (int): ID of the file
            mimetype (str): String of the file's mimetype
            views (int): Integer of the number of views the file has
            name (str): String of the file's name
            size (int): Integer of the file's size in bytes
            favorite (bool): Boolean of whether the file is favorited
            originalName (str = None): (optional) String of the file's original name
            url (str = None): (optional) String of the file's URL
            maxViews (int = None): (optional) Integer of the file's maximum number of views
            expiredAt (datetime.datetime = None): (optional) Datetime object of when the file will expire
            thumbnail (str = None): (optional) String of the file's thumbnail URL
            folderId (int = None): (optional) Integer of the file's folder ID
        """

        self.createdAt = createdAt
        self.id = id
        self.mimetype = mimetype
        self.views = views
        self.name = name
        self.size = size
        self.favorite = favorite
        self.originalName = originalName
        self.url = url
        self.maxViews = maxViews
        self.expiredAt = expiredAt
        self.thumbnail = thumbnail
        self.folderId = folderId
        self.__dict__.update(kwargs)


class Result:
    def __init__(self, success: bool, status_code: int, message: str = '', data: List[Dict] = None):
        """Result returned from low-level RestAdapter

        Args:
            success (bool): Boolean of whether the request was successful
            status_code (int): Standard HTTP Status code
            message (str = ''): Human readable result
            data (List[Dict] = None): Python List of Dictionaries (or maybe just a single Dictionary on error)
        """
        self.success = success
        self.status_code = status_code
        self.message = message
        self.data = data if data else []


class Invite:
    def __init__(
            self,
            id: int,
            code: str,
            createdAt: datetime,
            expiredAt: datetime,
            used: bool,
            createdById: int,
            **kwargs
        ):
        """Invite object used for managing invites

        Args:
            id (int): Integer ID of the invite
            code (str): String of the invite's code
            createdAt (datetime): Datetime object of when the invite was created
            expiredAt (datetime): Datetime object of when the invite will expire
            used (bool): Boolean of whether the invite has been used
            createdById (int): Integer ID of the user who created the invite
        """
        self.id = id
        self.code = code
        self.createdAt = createdAt
        self.expiredAt = expiredAt
        self.used = used
        self.createdById = createdById
        self.__dict__.update(kwargs)


class OAuth:
    def __init__(
        self,
        id: int,
        provider: str,
        userId: int,
        providerId: str,
        username: str,
        token: str,
        refresh: str,
        **kwargs
    ):
        """OAuth object used for managing OAuth

        Args:
            id (int): Integer ID of the OAuth
            provider (str): String of the OAuth's provider, one of 'DISCORD', 'GITHUB', 'GOOGLE'
            userId (int): Integer ID of the user who owns the OAuth
            providerId (str): String of the OAuth's provider ID
            username (str): String of the OAuth's connected account's username
            token (str): String of the OAuth's access token
            refresh (str): String of the OAuth's refresh token
        """
        self.id = id
        self.provider = provider
        self.userId = userId
        self.providerId = providerId
        self.username = username
        self.token = token
        self.refresh = refresh
        self.__dict__.update(kwargs)


class User:
    def __init__(
            self,
            id: int,
            uuid: str,
            username: str,
            avatar: str,
            token: str,
            administrator: bool,
            superAdmin: bool,
            systemTheme: str,
            embed: Embed,
            totpSecret: str,
            domains: List[str],
            oauth: Union[List['OAuth'], None] = None,
            ratelimit: [datetime, None] = None,
            **kwargs
    ):
        """User object used for managing users

        Args:
            id (int): Integer ID of the user
            uuid (str): String of the user's UUID
            username (str): String of the user's username
            avatar (str): String of the user's avatar, base64 encoded
            token (str): String of the user's token
            administrator (bool): Boolean of whether the user is an administrator
            superAdmin (bool): Boolean of whether the user is a super administrator
            systemTheme (str): String of the user's system theme
            embed (Embed): Embed object of the user's embed
            totpSecret (str): String of the user's TOTP secret
            domains (List[str]): List of Strings of the user's domains
            oauth (List[OAuth] = None): (optional) List of OAuth objects
            ratelimit (datetime = None): (optional) Datetime object of when the user's ratelimit expires
        """
        self.id = id
        self.uuid = uuid
        self.username = username
        self.avatar = avatar
        self.token = token
        self.administrator = administrator
        self.superAdmin = superAdmin
        self.systemTheme = systemTheme
        self.embed = embed
        self.totpSecret = totpSecret
        self.domains = domains
        self.oauth = oauth
        self.ratelimit = ratelimit
        self.__dict__.update(kwargs)