from random import shuffle, choice, seed

# Code that defines objects
values = range(1, 14)
kinds = ['hearts', 'diamonds', 'spades', 'clubs']


class Card:
    def __init__(self, value, kind):
        self.value = value
        self.kind = kind

    def __str__(self):
        return '{} of {}'.format(self.value, self.kind)

    def __lt__(self, other):
        return self.value < other.value

    def __gt__(self, other):
        return self.value > other.value

    def __eq__(self, other):
        return self.value == other.value

    def getValue(self):
        return self.value

    def getKind(self):
        return self.kind


class Deck:
    def __init__(self, shuffle=False):
        self.deck = [Card(value, kind) for value in range(1, 14) for kind in kinds]

        if shuffle:
            self.shuffle()

    def __str__(self):
        deck_list = ''
        for card in self.deck:
            deck_list += '{}\n'.format(card)
        return deck_list

    def getSize(self):
        return len(self.deck)

    def draw(self):
        return self.deck.pop()

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


class Player:
    def __init__(self, deck, type='naive'):
        self.deck = deck
        self.hand = list()
        self.type = type
        self.opponents = list()
        self.score = 0

    def setOpponents(self, players):
        for player in players:
            if player != self:
                self.opponents.append(player)

    def draw(self):
        if self.deck.getSize() > 0:
            self.hand.append(self.deck.draw())
            return self.hand[-1]
        else:
            return None

    def check(self, new_card):
        count = 0
        for card in self.hand:
            if card.getValue() == new_card.getValue():
                count += 1
        if count == 4:
            self.score += 1
            for card in list(self.hand):
                if card.getValue() == new_card.getValue():
                    self.removeCard(card)
            return card.getValue()
        else:
            return None

    def play(self):
        if len(self.hand) == 0:
            return None

        if self.type == 'naive':
            return Option(choice(self.hand), choice(self.opponents))

    def getScore(self):
        return self.score

    def getHand(self):
        return self.hand

    def removeCard(self, card):
        return self.hand.remove(card)

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

    def hasValue(self, card):
        value = card.getValue()
        for card in self.hand:
            if card.getValue() == value:
                return True
        return False

    def __str__(self):
        hand_list = ''
        for card in self.hand:
            hand_list += '{}\n'.format(card)
        return '{}score={}\n'.format(hand_list, self.getScore())


class Option:
    def __init__(self, card, player):
        self.card = card
        self.player = player

    def __str__(self):
        return '{}'.format(self.card)

    def getCard(self):
        return self.card

    def getPlayer(self):
        return self.player


class Game:
    def __init__(self, players=('naive', 'naive')):
        self.deck = Deck(shuffle=True)
        self.players = list()
        self.flag = 0
        self.quads = list()

        for type in players:
            self.players.append(Player(self.deck, type))

        for i in range(1, 8):
            for player in self.players:
                drawn_card = player.draw()
                player.check(drawn_card)

        for player in self.players:
            player.setOpponents(self.players)

    def play(self):
        cPlayer = self.players[self.flag]
        option = cPlayer.play()
        if option is not None:
            opponent = option.getPlayer()
            shown_card = option.getCard()
            if opponent.hasValue(shown_card):
                for card in list(opponent.getHand()):
                    if shown_card.getValue == card.getValue:
                        cPlayer.addCard(card)
                        opponent.removeCard(card)
                check_value = cPlayer.check(shown_card)
                if check_value is not None:
                    self.quads.append(check_value)
            else:
                check_value = cPlayer.check(cPlayer.draw())
                if check_value is not None:
                    self.quads.append(check_value)
        else:
            check_value = cPlayer.check(cPlayer.draw())
            if check_value is not None:
                self.quads.append(check_value)
        self.incrementFlag()
        return self.check()

    def check(self):
        if len(self.quads) == 13:
            return True
        else:
            return False

    def incrementFlag(self):
        self.flag = (self.flag + 1) % len(self.players)

    def __str__(self):
        player_list = ''
        for player in self.players:
            player_list += '{}\n'.format(player)
        return player_list


game = Game()

while True:
    if game.play():
        break