from enum import Enum, auto
import random
from typing import List, Optional, Tuple

from swiftstory.exception import WrongAction, JoinError
from swiftstory.player import Player
from swiftstory.board import Board
from swiftstory.status import error, success


class GameState(Enum):
    WAITING_NEW_JUDGE = auto(),
    WAITING_COLLECTION = auto(),
    WAITING_DESIGNATION = auto(),


class Game:
    def __init__(self, white_desc: List[str], black_desc: List[str]) -> None:

        self.state = GameState.WAITING_NEW_JUDGE

        self.players: List[Player] = []

        self.judge: Optional[Player] = None

        self.board = Board()
        self.board.white_pick = list(enumerate(white_desc))
        self.board.black_pick = list(enumerate(black_desc))

        random.shuffle(self.board.white_pick)
        random.shuffle(self.board.black_pick)

    def try_join(self, player: Player) -> str:
        if len(self.players) >= 10:
            raise JoinError('too many players in this game')

        cards: List[Tuple[int, str]] = []

        try:
            for _ in range(10):
                cards.append(self.board.pick_white_card())
        except IndexError:
            raise JoinError('not enough white cards for player')

        for card in cards:
            player.receive_card(card)

        self.players.append(player)

        for p in self.players:
            if p is not player:
                p.register_notification({'op': 'player_joined_game'})

        cards = [(idx, desc) for idx, (_, desc) in player.cards.items()]

        if self.state is GameState.WAITING_NEW_JUDGE:
            state = 'waiting_judge'
        elif self.state is GameState.WAITING_COLLECTION:
            state = 'waiting_collection'
        else:
            state = 'waiting_designation'

        return success({'cards': cards, 'game_state': state})


    def try_become_judge(self, player: Player) -> str:
        if self.state is not GameState.WAITING_NEW_JUDGE:
            # TODO what if the judge has quit ?
            raise WrongAction('Someone is judge already')

        self.judge = player
        self.board.reveal_next_black_card()

        self.state = GameState.WAITING_COLLECTION

        for p in self.players:
            if p is not player:
                p.register_notification({'op': 'judge_designed'})

        return self.try_view_black_card(player)


    def try_play_card(self, player: Player, card_id: int) -> str:
        if self.state is not GameState.WAITING_COLLECTION:
            raise WrongAction('Who asked you to play now ?!')

        if self.judge is player:
            raise WrongAction('You\'re the judge, you silly')
        elif player.has_played:
            raise WrongAction('You already played, you dumb ass')

        try:
            card = player.pop_card(card_id)
        except IndexError:
            raise WrongAction('Invalid card id')

        player.has_played = True

        self.board.play_card(player, card)

        if self.judge is None:
            raise ValueError("There is no judge")
        self.judge.register_notification({'op': 'card_played'})

        return success({'card_id': card_id})


    def try_collect_cards(self, player: Player) -> str:
        if self.state is not GameState.WAITING_COLLECTION:
            raise WrongAction("Do you think it's the moment for collection !?")

        if self.judge is not player:
            raise WrongAction('You\'re not the judge, you fool!')

        self.board.shuffle_played_cards()

        # we prevent the others to play
        self.state = GameState.WAITING_DESIGNATION

        for p in self.players:
            if p is not player:
                p.register_notification({'op': 'cards_collected'})

        return self.try_view_played_cards(player)


    def try_designate_card(self, player: Player, card_id: Optional[int]) -> str:
        if self.state is not GameState.WAITING_DESIGNATION:
            raise WrongAction('Not now, moron !')

        if self.judge is not player:
            raise WrongAction('Who do you think you are !?')

        def move_on() -> str:
            self.judge = None

            for p in self.players:
                if p is not player:
                    p.register_notification({'op': 'judge_needed'})

            self.state = GameState.WAITING_NEW_JUDGE
            return success(None)

        if not self.board.played_cards:
            return move_on()

        if card_id is None:
            raise WrongAction('There are cards on the board, pick one !')

        # TODO check exception
        try:
            card, winner = self.board.played_cards[card_id]
        except IndexError:
            return error('Invalid card')

        winner.inc_score()

        # put the cards back in the deck
        self.board.recycle_played_cards()

        # reset the state of the players
        for p in self.players:
            if p.has_played:
                idx = p.receive_card(self.board.pick_white_card())

                p.register_notification({
                    'op': 'received_card',
                    'content': {
                        'card': {
                            'id': idx,
                            'desc': p.cards[idx][1],
                            },
                        },
                    })
                p.has_played = False

        return move_on()

    def try_view_player_cards(self, player: Player) -> str:
        return success([(idx, desc) for idx, (_, desc) in player.cards.items()])

    def try_view_played_cards(self, player: Player) -> str:
        if self.state is not GameState.WAITING_DESIGNATION:
            raise WrongAction('Not now, moron !')

        return success([desc for (_, desc), _ in self.board.played_cards])

    def try_view_black_card(self, player: Player) -> str:
        card = self.board.current_black_card

        if card is not None:
            return success(card[1])

        raise WrongAction('The black card has not been revealed yet')

    def disconnect(self, player: Player) -> None:
        if self.judge is player:
            self.judge = None

            for p in self.players:
                p.register_notification({'op': 'judge_needed'})

            for card, p in self.board.played_cards:
                p.receive_card(card)

                p.register_notification({
                    'op': 'received_card',
                    'content': {
                        'card': {
                            'id': card[0],
                            'desc': card[1],
                            },
                        },
                    })
                p.has_played = False

            self.board.played_cards = []
            self.state = GameState.WAITING_NEW_JUDGE