import enum
from typing import Optional, Dict
import pydantic
from datetime import datetime


class Qualification(pydantic.BaseModel):
    start_date: Optional[datetime]
    vote_format: Optional[str]
    vote_pool: Optional[int]
    vote_time: Optional[int]
    vote_veto_logic: Optional[str]


class Settings(pydantic.BaseModel):
    qualification = Qualification


class LocalizedFields(pydantic.BaseModel):
    name: Optional[str]
    description: Optional[str]
    avatar: Optional[str]
    backgroundAvatar: Optional[str]
    prize: Optional[str]


class Localizations(pydantic.BaseModel):
    en: Optional[LocalizedFields]
    ru: Optional[LocalizedFields]


class Attributes(pydantic.BaseModel):
    class Status(str, enum.Enum):
        UPCOMING = 'UPCOMING'
        ONGOING = 'ONGOING'
        ENDED = 'ENDED'
        CANCELED = 'CANCELED'

    class Bracket(str, enum.Enum):
        SINGLE_ELIMINATION = 'SINGLE_ELIMINATION'
        DOUBLE_ELIMINATION = 'DOUBLE_ELIMINATION'
        GROUP = 'GROUP'
        GSL = 'GSL'

    class BracketLogic(str, enum.Enum):
        ROUND_BY_ROUND = 'ROUND_BY_ROUND'
        FOLLOW_BY = 'FOLLOW_BY'

    class AccessType(str, enum.Enum):
        ACCESS_PUBLIC = 'ACCESS_PUBLIC'
        ACCESS_BY_LINK = 'ACCESS_BY_LINK'
        ACCESS_BY_NAME = 'ACCESS_BY_NAME'

    name: str
    description: str
    avatar: str
    background_avatar: str
    prize: str
    published: int
    status: Status
    open_registration_datetime: Optional[datetime]
    close_registration_datetime: Optional[datetime]
    start_datetime: Optional[datetime]
    publish_datetime: Optional[datetime]
    bracket: Bracket
    bracket_logic: BracketLogic
    groups_count: Optional[int]
    group_size: Optional[int]
    reserved_size: Optional[int]
    third_place_match: Optional[int]
    total_slots: Optional[int]
    empty_slots: Optional[int]
    access_type: AccessType
    create_datetime: Optional[datetime]
    update_datetime: Optional[datetime]
    settings: Optional[Settings]
    lang: Optional[Localizations]


class Game(pydantic.BaseModel):
    name: Optional[str]
    logo: Optional[str]
    create_datetime: Optional[datetime]
    update_datetime: Optional[datetime]


class GameMode(pydantic.BaseModel):
    title: Optional[str]
    size: Optional[int]
    type: Optional[str]


class Organizer(pydantic.BaseModel):
    name: Optional[str]
    logo: Optional[str]
    url: Optional[str]


class Tournament(pydantic.BaseModel):
    id: int
    type: str
    attributes: Attributes
    relationships: dict
    games: Dict[str, Game]
    game_modes: Dict[str, GameMode]
    organizers: Dict[str, Organizer]

    @property
    def game(self) -> str:
        game_id = str(self.relationships['game']['data']['id'])
        game = self.games.get(game_id)
        if game:
            return game.name
        return ''

    @property
    def icon(self) -> str:
        return self.attributes.avatar

    @property
    def status(self) -> Attributes.Status:
        return self.attributes.status

    @property
    def name(self):
        # todo: localization
        return self.attributes.name

    @property
    def access_type(self) -> Attributes.AccessType:
        return self.attributes.access_type

    @property
    def organizer(self) -> str:
        organizer_id = str(self.relationships['organizer']['data']['id'])
        organizer = self.organizers.get(organizer_id)
        if organizer:
            return organizer.name
        return ''

    @property
    def start_time(self) -> datetime:
        return self.attributes.start_datetime

    @property
    def total_slots(self) -> int:
        return self.attributes.total_slots

    @property
    def empty_slots(self) -> int:
        return self.attributes.empty_slots

    @property
    def prize(self) -> str:
        return self.attributes.prize

    @property
    def game_mode(self):
        game_mode_id = str(self.relationships['game_mode']['data']['id'])
        game_mode = self.game_modes.get(game_mode_id)
        if game_mode:
            return game_mode.title
        return ''