'''
    Game play.

    Add in a max turns because sometimes it just doesn't get there quickly. 
'''
# Create the player decks
players = createDecks(7)
# Track number of turns
turns = 0
# Artificial limit in case there are no winners by this number
max_turns = 400

'''
    Game play here: Game ends when EITHER of the player lists is empty, so 
    we create a while loop that simply checks that both player lists are 
    not empty. 
'''
while len(players[0]) and len(players[1]):
    '''
        Track the number of turns, if we hit the maximum, just quit. Occasionally, 
        this case will be hit as the randomness of this game can produce really long
        games. 
    '''
    turns += 1
    if turns >= max_turns:
        break

    '''
        Take a card from the top of each players deck (list), then 
        add them to the current_cards list. These are cards that will
        eventually go to the winner of the match. 
    '''
    p1Card = players[0].pop()
    p2Card = players[1].pop()
    current_cards = [p1Card, p2Card]
    print("P1 = {}, P2 = {}".format(p1Card,p2Card))

   # ADD GAME CODE HERE
}

import random

def createDecks(shuffle_count = 7):
    '''
        Create a 52 card deck, shuffle it, and return two even decks.

        ARGUMENT:
            shuffle_count : Number of times to shuffle the deck, default value
                            is 7, so if no value is provided when calling the function
                            the deck will be shuffled 7 times. Otherwise, it is shuffled
                            the number of times the caller indicates. 

        RETURNS:
            A list of lists : [[0][1]].

            List[0] = Player 1
            List[1] = Player 2
    '''

    '''
        Deck of cards is made of 4 suits: Diamonds, Hearts, Clubs Spades

        Card values are 2-14
            2-10 for 2-10
            11-14 for J, Q, K, A

        Build a deck with 4 sets (one for each suit) of 2-14
    '''
    card_face = [2,3,4,5,6,7,8,9,10,11,12,13,14]
    deck = []
    for i in range(4):
        for card in card_face:
            deck.append(card)

    '''
        Now we need to shuffle the deck we have. Shuffle as many
        times as shuffle_count indicates (whose default is 7) 
    '''
    for i in range(shuffle_count):
        random.shuffle(deck)

    '''
        Create the player decks, one for each of the two players. These
        are created as lists within another list. 

        The loop goes over the entire deck that we created using the modulo (%) 
        operator. Using N % 2 will return either a 0 or 1 allowing us to evenly
        distribute the cards to each player list (deck).
    '''
    players = [[],[]]
    for i in range(len(deck)):
        players[i % 2].append(deck[i]) 

    '''
        Finally, return the two player decks (lists) contained in one outer list.
    '''
    return players   

def prependCards(deck, cards):
    '''
        We don't want to just add the win cards to the top of the deck, they should be added to 
        the bottom of the deck. 
        
        To do so we simply add each of the cards to the start of the deck.

        ARGUMENTS:
            deck    : Player deck(list) we want to add cards to
            cards   : List of cards to add to deck.

        RETURN:
            Nothing
    '''
    while len(cards):
        deck.insert(0,cards.pop())

def doWar(player_deck1, player_deck2, war_count):
    '''
        doWar() function happens when the two players have identical cards. 

        PARAMETERS:
        player_deck1 : List of integers representing a deck of cards for Player 1
        player_deck2 : List of integers representing a deck of cards for Player 1
        war_count    : Integer representing the number of cards that are at risk. 
                       Total cards a player can lose are war_count + 1. The war_count 
                       at risk and one more to see who wins. 

        RETURNS:
        The return of the function is a 3 part tuple that can be accessed just like 
        a list, that is, with indexes. 

        result[0] - Flip card of the player1 after flipping the war_count cards, or
                    None if player 1 does not have enough cards and forfiets. 
        result[1] - Flip card of player 2 after flipping the war_count cards, or
                    None if player 2 does not have enough cards and forfiets. 
        result[2] - All of the cards, including the flip cards, that are at risk. 

        NOTES:
        If a player loses because of a forfiet then losers cards are all added to the risk cards.
        Whomever forfiets will have no return flip card, which is a special case to look for.

        If no forfiet happens it is up to the caller to detemine the winner with the return
        results of the call.  

        RULES:
            - If either player does not have enough cards to continue, they forfiet their
              remaining cards to the other (in the risk cards) and end up with an empty deck. 
            - Cards at risk are war_count + 1 for each player. Whomever wins takes all the cards
            - If another war occurs, the function is called recursively until there is a winner
              of the war or someone runs out of cards and forfiets.
    '''
    player1_flip = None
    player2_flip = None
    risk_cards = []

    '''
        Determine if either player does not have enough cards to continue. 
        
        If either player does not have enough cards, move all of that players cards
        onto the risk pile. Then, select one card for the "winner". 

        Upon return, it helps the caller figure out what happened. If either of the players
        flip cards are None, then that player forfieted and the other player wins. 
    '''
    if len(player_deck1) < war_count + 1:
        risk_cards.extend(player_deck1.copy())
        player_deck1.clear()
        player2_flip = player_deck2[-1]
    elif len(player_deck2) < war_count + 1:
        risk_cards.extend(player_deck2.copy())
        player_deck2.clear()
        player1_flip = player_deck1[-1]

    '''
        If there was no forfiet, collect war_count cards from each players
        deck and add them to the risk cards. 

        Next, take the next top card from each players deck as the flip card
        to determine who wins the war. These are also added to the risk cards. 
    '''
    if len(player_deck1) and len(player_deck2):
        '''
            Collect all the face down at risk cards
        '''
        for i in range(war_count):
            risk_cards.append(player_deck1.pop())
            risk_cards.append(player_deck2.pop())

        '''
            Get the final card they will flip, also added to the risk cards
        '''
        player1_flip = player_deck1.pop()
        player2_flip = player_deck2.pop()
        risk_cards.extend([player1_flip, player2_flip])

    '''
        If the result is that both players have flipped the same card value again, 
        we have another war. 

        In this case, call the function again (recursively) and get the return values. 
        The return risk cards are added to the risk_cards list because every card 
        played during a war will go to the winner. 
    '''
    while player1_flip == player2_flip:
        print("Continuation War")
        player1_flip, player2_flip, risk = doWar(player_deck1, player_deck2, war_count)
        risk_cards.extend(risk)

    '''
        Return the results of the war. 

        player1_flip : Player 1 flip card, if None this player forfieted
        player2_flip : Player 2 flip card, if None this player forfieted
        risk_cards   : All of the cards that were played during the war. These 
                       will go to the winner. 
    '''
    return player1_flip, player2_flip, risk_cards