import random
from Ledger import Ledger

"""
Class which describes playing cards
"""
class Card():
    """
    A joker card has value 0 and suit 0
    """
    HEARTS = 1
    DIAMONDS = 2
    SPADES = 3
    CLUBS = 4

    def __init__(self, value, suit) -> None:
        self.value = value
        self.suit = suit
        self.hidden = False

    def turn_card(self):
        # XOR to flip hidden element
        self.hidden = self.hidden != True

    def get_value(self):
        return self.value
    
    def get_suit(self):
        return self.suit

    def __str__(self) -> str:
        suits = ["J", "♥", "♦", "♠", "♣"]
        special_cards = {1: "A", 11: "J", 12: "Q", 13: "K"}
        strValue = ""

        if self.value in special_cards.keys():
            strValue = special_cards[self.value]
        else:
            strValue = str(self.value)

        string = ""
        string = f"{suits[self.suit]}{strValue}"
        if self.hidden:
            string = "??"
        return string
    
    def __repr__(self) -> str:
        return str(self)
"""
Class for interacting with a deck of cards
"""
class Deck():
    def __init__(self, joker = False) -> None:
        self.deck = []
        self.discard = []
        self.joker = joker

        self.deck.extend([Card(x, Card.HEARTS) for x in range(1, 13)])
        self.deck.extend([Card(x, Card.DIAMONDS) for x in range(1, 13)])
        self.deck.extend([Card(x, Card.SPADES) for x in range(1, 13)])
        self.deck.extend([Card(x, Card.CLUBS) for x in range(1, 13)])

        if joker:
            self.deck.append(Card(0, 0))

    def shuffle(self):
        random.shuffle(self.deck)

    def sort(self):
        self.deck.sort()
        
    def take_from_deck(self):
        card = self.deck.pop()
        return card
    
    def return_to_deck_top(self, card):
        self.deck.insert(0, card)

    def returnToDeckBottom(self, card):
        self.deck.append(card)

    def addToDiscard(self, card):
        self.discard.insert(0, card)

    def returnFromDiscard(self):
        self.returnToDeckTop(self.discard.pop())

    def __str__(self) -> str:
        string = ""
        for card in self.deck:
            string += str(card)
        return string
    
class Hand():
    def __init__(self) -> None:
        self.hand = []

    def sortHand(self):
        self.hand.sort()

    def add_to_hand(self, card):
        self.hand.append(card)

    def remove_from_hand(self, index):
        return self.hand.pop(index)
    
    def hide_card(self, index):
        card = self.remove_from_hand(0)
        card.turn_card()
        self.add_to_hand(card)
    
    def __str__(self) -> str:
        string = ""
        for card in self.hand:
            string += str(card)
            string += " "
        return string
    
    def __iter__(self):
        self.iter = iter(self.hand)
        return self.iter

    def __next__(self):
        return next(self.iter)
    

class BlackJack:
    def __init__(self) -> None:
        self.deck = Deck()
        self.playerHand = Hand()
        self.dealerHand = Hand()
        self.ledger = Ledger()
        
    def deal_card(self, hand):
        hand.add_to_hand(self.deck.take_from_deck())

    def game_setup(self):
        # Deal cards in alternate order
        self.deck.shuffle()
        for _ in range(2):
            self.deal_card(self.playerHand)
            self.deal_card(self.dealerHand)

        # Hide one of the dealers cards
        self.dealerHand.hide_card(1)

    def play_game(self):
        # Load player statistics

        self.game_setup()
    
        # Show Cards to player
        print("Player Hand:", end=" ")
        print(self.playerHand)
        print("Dealer Hand:", end=" ")
        print(self.dealerHand)



def main():
    game = BlackJack()
    game.play_game()

if __name__ == "__main__":
    main()