"""Blackjack game."""
import requests


class Card:
    """Class for card."""

    def __init__(self, value: str, suit: str, code: str):
        """
        Konstruktor teeb kaardi objekti, võttes sisendparameetriteks kaardi väärtuse, masti ja koodi.

        Väärtused peab salvestama sama nimega isendiväljadele (card, suit, code).

        values = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'JACK', 'QUEEN', 'KING', 'ACE']

        suits = ['SPADES', 'DIAMONDS', 'HEARTS', 'CLUBS']

        codes = {'AS', '2S', '3S', '4S', '5S', '6S', '7S', '8S', '9S', '0S', 'JS', 'QS', 'KS',
        'AD', '2D', '3D', '4D', '5D', '6D', '7D', '8D', '9D', '0D', 'JD', 'QD', 'KD',
        'AC', '2C', '3C', '4C', '5C', '6C', '7C', '8C', '9C', '0C', 'JC', 'QC', 'KC',
        'AH', '2H', '3H', '4H', '5H', '6H', '7H', '8H', '9H', '0H', 'JH', 'QH', 'KH'}.
        """
        print("aaaa")
        values = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'JACK', 'QUEEN', 'KING', 'ACE']

        suits = ['SPADES', 'DIAMONDS', 'HEARTS', 'CLUBS']

        codes = {'AS', '2S', '3S', '4S', '5S', '6S', '7S', '8S', '9S', '0S', 'JS', 'QS', 'KS',
                 'AD', '2D', '3D', '4D', '5D', '6D', '7D', '8D', '9D', '0D', 'JD', 'QD', 'KD',
                 'AC', '2C', '3C', '4C', '5C', '6C', '7C', '8C', '9C', '0C', 'JC', 'QC', 'KC',
                 'AH', '2H', '3H', '4H', '5H', '6H', '7H', '8H', '9H', '0H', 'JH', 'QH', 'KH'}
        self.top_down = False
        if value in values:
            self.value = value
        if suit in suits:
            self.suit = suit
        if code in codes:
            self.code = code
        print(self.value, self.suit)

    def __str__(self):
        """Prindib kaardi koodi juhul, kui top_down == False, vastasel juhul prindib ??."""
        return self.code if self.top_down is False else "??"

    def __repr__(self) -> str:
        """Tagastab code-väljal oleva väärtuse."""
        return self.code

    def __eq__(self, other) -> bool:
        """
        Võrdleb Card objekti teise objektiga. Tagastab True, kui teine object on Card tüüpi.

        ja sama masti ning väärtusega.
        """
        return isinstance(other, Card) and self.suit == other.suit and self.value == other.value


class Deck:
    """Class for deck."""

    DECK_BASE_API = "https://deckofcardsapi.com/api/deck/"

    def __init__(self, deck_count: int = 1, shuffle: bool = False):
        """
        Konstruktor teeb Deck objekti. Saab sisendiks pakkide arvu (mitu 52 kaardist pakki on) ja boolean muutuja.

        mis määrab, kas kaardipakid peavad olema segatud või ei. Salvestada tuleb deck_count ning ka shuffeled
        väärtused. Viimase salvestamiseks kasutada isendimuutujat nimega is_shuffled. Lisaks peab isendimuutujas nimega
        remaining hoidma kaardipakis olevate kaartide arvu (võib kasutada ka property'd) Kaardipaki genereerimiseks
        kasutada

        Kuna klass peab toimima ka ilma interneti ühenduseta, siis on tuleb valmis genereerida ka n-ö tagavara
        kaardipakk, mida saaks kasutada, kui api lõpetab töötamise. Tagavara kaardipakk salvestada muutujasse
        _backup_deck. Seda tagavara pakki on mõistlik sünkroniseerida API-st tuleneva pakiga. Ehk siis kui API ütleb,
        et järgmine kaart on S3, siis tuleks see ka tagavara pakist eemaldada jne.
        """
        try:
            self.deck_count = deck_count
            self.is_shuffled = shuffle
            self._backup_deck = Deck._generate_backup_pile(self.deck_count)
            self.remaining = 52 * self.deck_count
            if self.is_shuffled:
                self.result = self._request(f"new/shuffle/?deck_count={self.deck_count}")
            else:
                self.result = self._request(f"new/?deck_count={self.deck_count}")
            self.top_down = False
            if self.is_shuffled is True:
                self.shuffle()
            if self.result is None or ('success' in self.result and self.result['success'] is True):
                pass
            if self.result and "deck_id" in self.result:
                self.remaining = self.result["remaining"]
                self.is_shuffled = self.result['shuffled']
                self.deck_id = self.result['deck_id']
            else:
                self.remaining = len(self._backup_deck)
                self.is_shuffled = False
                self.deck_id = None
        except AttributeError:
            pass

    def shuffle(self) -> None:
        """Segab kaardipaki, kasutada https://deckofcardsapi.com/api/deck/<deck_id>/shuffle/."""
        try:
            result = self._request(f"{self.deck_id}/shuffle/")
            if result is None or ('success' in result and result['success'] is True):
                pass
        except AttributeError:
            pass

    def draw_card(self, top_down: bool = False):  # -> Optional[Card]
        """
        Draw card from the deck.

        :return: card instance.
        """
        try:
            result = []
            if self.remaining == 0:
                return None
            if self.deck_id is not None:
                result = self._request(str(self.deck_id) + "/draw/?count=1")
            if result and result["success"]:
                card = result['cards'][0]
                new_card = Card(card['value'], card['suit'], card['code'])
                self._backup_deck.remove(new_card)
                self.remaining -= 1
                new_card.top_down = top_down
                return new_card
            else:
                new_card = self._backup_deck.pop(0)
                self.remaining -= 1
                new_card.top_down = top_down
                return new_card
        except AttributeError:
            return None

    def _request(self, url: str) -> dict:
        """
        Update deck.

        :param url:
        :return:
        """
        try:
            url = Deck.DECK_BASE_API + url
            try:
                response = requests.get(url)
            except requests.exceptions.RequestException:
                response = None
            if response is None:
                pass
            if response is not None and response.status_code == requests.codes.ok:
                thing = response.json()
                return thing
            else:
                pass
        except AttributeError:
            pass

    @staticmethod
    def _generate_backup_pile(deck_count=1):  # -> List[Card]:
        """Generate backup pile."""
        card_list = []
        cards = ['2S', '3S', '4S', '5S', '6S', '7S', '8S', '9S', '10S', 'JACKS', 'QUEENS', 'KINGS', 'ACES',
                 '2D', '3D', '4D', '5D', '6D', '7D', '8D', '9D', '10D', 'JACKD', 'QUEEND', 'KINGD', 'ACED',
                 '2C', '3C', '4C', '5C', '6C', '7C', '8C', '9C', '10C', 'JACKC', 'QUEENC', 'KINGC', 'ACEC',
                 '2H', '3H', '4H', '5H', '6H', '7H', '8H', '9H', '10H', 'JACKH', 'QUEENH', 'KINGH', 'ACEH']
        codes = ['2S', '3S', '4S', '5S', '6S', '7S', '8S', '9S', '0S', 'JS', 'QS', 'KS', 'AS',
                 '2D', '3D', '4D', '5D', '6D', '7D', '8D', '9D', '0D', 'JD', 'QD', 'KD', 'AD',
                 '2C', '3C', '4C', '5C', '6C', '7C', '8C', '9C', '0C', 'JC', 'QC', 'KC', 'AC',
                 '2H', '3H', '4H', '5H', '6H', '7H', '8H', '9H', '0H', 'JH', 'QH', 'KH', 'AH']
        for c in range(len(cards)):
            if cards[c][-1] == "S":
                card_list.append(Card(cards[c][:-1], 'SPADES', codes[c]))
            elif cards[c][-1] == "D":
                card_list.append(Card(cards[c][:-1], 'DIAMONDS', codes[c]))
            elif cards[c][-1] == "C":
                card_list.append(Card(cards[c][:-1], 'HEARTS', codes[c]))
            elif cards[c][-1] == "H":
                card_list.append(Card(cards[c][:-1], 'CLUBS', codes[c]))
        return card_list * deck_count


if __name__ == '__main__':
    d = Deck(shuffle=True)
    print(d.remaining)  # 52
    card1 = d.draw_card()  # Random card
    print(d.draw_card())
    print(card1 in d._backup_deck)  # False
    print(d._backup_deck)  # 51 shuffled cards
    d2 = Deck(deck_count=2)
    print(d2._backup_deck)  # 104 ordered cards (deck after deck)