algorithm.py

from random import shuffle
from collections import Counter
from classes import *

class Algorithm:
    class Card:
        def __init__(self):
            self.card = [
                {"name": "3D", "value": 1, "number": 3, "image": "D"},
                {"name": "3C", "value": 2, "number": 3, "image": "C"},
                {"name": "3H", "value": 3, "number": 3, "image": "H"},
                {"name": "3S", "value": 4, "number": 3, "image": "S"},

                {"name": "4D", "value": 5, "number": 4, "image": "D"},
                {"name": "4C", "value": 6, "number": 4, "image": "C"},
                {"name": "4H", "value": 7, "number": 4, "image": "H"},
                {"name": "4S", "value": 8, "number": 4, "image": "S"},

                {"name": "5D", "value": 9, "number": 5, "image": "D"},
                {"name": "5C", "value": 10, "number": 5, "image": "C"},
                {"name": "5H", "value": 11, "number": 5, "image": "H"},
                {"name": "5S", "value": 12, "number": 5, "image": "S"},

                {"name": "6D", "value": 13, "number": 6, "image": "D"},
                {"name": "6C", "value": 14, "number": 6, "image": "C"},
                {"name": "6H", "value": 15, "number": 6, "image": "H"},
                {"name": "6S", "value": 16, "number": 6, "image": "S"},

                {"name": "7D", "value": 17, "number": 7, "image": "D"},
                {"name": "7C", "value": 18, "number": 7, "image": "C"},
                {"name": "7H", "value": 19, "number": 7, "image": "H"},
                {"name": "7S", "value": 20, "number": 7, "image": "S"},

                {"name": "8D", "value": 21, "number": 8, "image": "D"},
                {"name": "8C", "value": 22, "number": 8, "image": "C"},
                {"name": "8H", "value": 23, "number": 8, "image": "H"},
                {"name": "8S", "value": 24, "number": 8, "image": "S"},

                {"name": "9D", "value": 25, "number": 9, "image": "D"},
                {"name": "9C", "value": 26, "number": 9, "image": "C"},
                {"name": "9H", "value": 27, "number": 9, "image": "H"},
                {"name": "9S", "value": 28, "number": 9, "image": "S"},

                {"name": "TD", "value": 29, "number": 10, "image": "D"},
                {"name": "TC", "value": 30, "number": 10, "image": "C"},
                {"name": "TH", "value": 31, "number": 10, "image": "H"},
                {"name": "TS", "value": 32, "number": 10, "image": "S"},

                {"name": "JD", "value": 33, "number": 11, "image": "D"},
                {"name": "JC", "value": 34, "number": 11, "image": "C"},
                {"name": "JH", "value": 35, "number": 11, "image": "H"},
                {"name": "JS", "value": 36, "number": 11, "image": "S"},

                {"name": "QD", "value": 37, "number": 12, "image": "D"},
                {"name": "QC", "value": 38, "number": 12, "image": "C"},
                {"name": "QH", "value": 39, "number": 12, "image": "H"},
                {"name": "QS", "value": 40, "number": 12, "image": "S"},

                {"name": "KD", "value": 41, "number": 13, "image": "D"},
                {"name": "KC", "value": 42, "number": 13, "image": "C"},
                {"name": "KH", "value": 43, "number": 13, "image": "H"},
                {"name": "KS", "value": 44, "number": 13, "image": "S"},

                {"name": "AD", "value": 45, "number": 14, "image": "D"},
                {"name": "AC", "value": 46, "number": 14, "image": "C"},
                {"name": "AH", "value": 47, "number": 14, "image": "H"},
                {"name": "AS", "value": 48, "number": 14, "image": "S"},

                {"name": "2D", "value": 49, "number": 15, "image": "D"},
                {"name": "2C", "value": 50, "number": 15, "image": "C"},
                {"name": "2H", "value": 51, "number": 15, "image": "H"},
                {"name": "2S", "value": 52, "number": 15, "image": "S"}]

        def shuffleDeck(self):
            deck = [i + 1 for i in range(52)]
            shuffle(deck)
            deck = self.getCardNames(deck)
            return deck

        def getCardNames(self, values):
            names = []
            for i in range(len(values)):
                cardname = list(filter(lambda x: x['value'] == values[i], self.card))[0]['name']
                names.append(cardname)
            return names

        def getCardValues(self, cardnames):
            values = []
            for i in range(len(cardnames)):
                cardvalue = list(filter(lambda x: x['name'] == cardnames[i], self.card))[0]['value']
                values.append(cardvalue)
            return values

        def getCardNumbers(self, cardnames):
            numbers = []
            for i in range(len(cardnames)):
                cardnumb = list(filter(lambda x: x['name'] == cardnames[i], self.card))[0]['number']
                numbers.append(cardnumb)
            return numbers

        def getCardImage(self, cardnames):
            images = []
            for i in range(len(cardnames)):
                cardimg = list(filter(lambda x: x['name'] == cardnames[i], self.card))[0]['image']
                images.append(cardimg)
            return images

        def sortingCards(self, cardnames):
            values = self.getCardValues(cardnames)
            values.sort()
            cardName = self.getCardNames(values)
            return cardName

        def sortingPairs(self, pairs):
            tempPair = pairs
            sortedPair = []
            for i in range(len(pairs)):
                scorePair = [self.getPairScore(x) for x in tempPair]
                index = scorePair.index(min(scorePair))
                lowestPair = tempPair[index]
                sortedPair.append(lowestPair)
                tempPair = tempPair[:index] + tempPair[index + 1:]
            return sortedPair

        def isSingle(self, card):
            return len(card) == 1

        def isPair(self, cardnames):
            if len(cardnames) == 2:
                values = self.getCardNumbers(cardnames)
                if len(set(values)) == 1: return True
            return False

        def isTris(self, cardnames):
            if len(cardnames) == 3:
                values = self.getCardNumbers(cardnames)
                if len(set(values)) == 1: return True
            return False

        def isFours(self, cardnames):
            if len(cardnames) == 4:
                values = self.getCardNumbers(cardnames)
                if len(set(values)) == 1: return True
            return False

        def isStraight(self, cardnames):
            if len(cardnames) == 5:
                sortedCards = self.sortingCards(cardnames)
                cardNumbers = self.getCardNumbers(sortedCards)
                x = cardNumbers
                if (x[0] == 11 and x[1] == 12 and x[2] == 13 and x[3] == 14 and x[4] == 15): return False
                if (x[0] == 3 and x[1] == 4 and x[2] == 5 and x[3] == 6 and x[4] == 15): return True
                if (x[0] == 3 and x[1] == 4 and x[2] == 5 and x[3] == 14 and x[4] == 15): return True
                return (x[0] + 1 == x[1] and x[1] + 1 == x[2] and x[2] + 1 == x[3] and x[3] + 1 == x[4])
            return False

        def isFlush(self, cardnames):
            if len(cardnames) == 5:
                cardImages = self.getCardImage(cardnames)
                if len(set(cardImages)) == 1: return True
            return False

        def isFullHouse(self, cardnames):
            if len(cardnames) == 5:
                sortedCards = self.sortingCards(cardnames)
                array1 = sortedCards[0:3]
                array2 = sortedCards[3:5]
                if (self.isTris(array1) and self.isPair(array2)): return True

                array1 = sortedCards[0:2]
                array2 = sortedCards[2:5]
                if (self.isTris(array2) and self.isPair(array1)): return True
            return False

        def isFourCards(self, cardnames):
            if len(cardnames) == 5:
                sortedCards = self.sortingCards(cardnames)
                array1 = sortedCards[0:4]
                array2 = sortedCards[1:5]
                if (self.isFours(array1) or self.isFours(array2)): return True
            return False

        def isStraightFlush(self, cardnames):
            return (self.isStraight(cardnames) and self.isFlush(cardnames))

        def isCombo(self, cardnames):
            return (self.isStraight(cardnames) or self.isFlush(cardnames) or
                    self.isFullHouse(cardnames) or self.isFourCards(cardnames) or
                    self.isStraightFlush(cardnames))

        def getPair(self, cardnames):
            sortedCards = self.sortingCards(cardnames)
            pair = []
            for i in range(len(sortedCards) - 1):
                for j in range(i + 1, len(sortedCards)):
                    if self.getCardNumbers([sortedCards[i]]) == self.getCardNumbers([sortedCards[j]]):
                        pair.append([sortedCards[i], sortedCards[j]])
                    else:
                        break
            if len(pair) > 0:
                return pair

        def getFixPair(self, cardnames):
            sortedCards = self.sortingCards(cardnames)
            pairs = []
            # Four cards
            fourCard = self.getFourCards(sortedCards)
            if fourCard:
                sortedCards = [x for x in sortedCards if not (any(x in cards for cards in fourCard))]
                for cards in fourCard:
                    pairs.append([cards[0], cards[1]])
                    pairs.append([cards[2], cards[3]])
            # Three cards
            trisCard = self.getTris(sortedCards)
            if trisCard:
                sortedCards = [x for x in sortedCards if not (any(x in cards for cards in trisCard))]
                for cards in trisCard:
                    pairs.append([cards[0], cards[1]])
            # Pair
            pairCard = self.getPair(sortedCards)
            if pairCard:
                for cards in pairCard:
                    pairs.append(cards)
            pair = self.sortingPairs(pairs)
            if len(pair) > 0:
                return pair

        def getTris(self, cardnames):
            sortedCards = self.sortingCards(cardnames)
            tris = []
            for i in range(len(sortedCards) - 2):
                for j in range(i + 1, len(sortedCards) - 1):
                    for k in range(j + 1, len(sortedCards)):
                        if self.getCardNumbers([sortedCards[i]]) == self.getCardNumbers(
                                [sortedCards[j]]) == self.getCardNumbers([sortedCards[k]]):
                            tris.append([sortedCards[i], sortedCards[j], sortedCards[k]])
            if len(tris) > 0:
                return tris

        def getFourCards(self, cardnames):
            sortedCards = self.sortingCards(cardnames)
            four = []
            for i in range(len(sortedCards) - 3):
                array = sortedCards[i:i + 4]
                if self.isFours(array):
                    four.append(array)
            if len(four) > 0:
                return four

        def getStraight(self, cardnames):
            sortedCards = self.sortingCards(cardnames)
            straight = []
            if len(sortedCards) >= 5:
                for i in range(len(sortedCards) - 4):
                    for j in range(i, len(sortedCards) - 4):
                        for k in range(j, len(sortedCards) - 4):
                            for l in range(k, len(sortedCards) - 4):
                                for m in range(l, len(sortedCards) - 4):
                                    temp = (sortedCards[i], sortedCards[j + 1], sortedCards[k + 2], sortedCards[l + 3],
                                            sortedCards[m + 4])
                                    if self.isStraight(list(temp)):
                                        if not (self.isStraightFlush(list(temp))):
                                            straight.append(list(temp))
            return straight

        def getFlush(self, cardnames):
            sortedCards = self.sortingCards(cardnames)
            flush = []
            if len(sortedCards) >= 5:
                for i in range(len(sortedCards) - 4):
                    for j in range(i, len(sortedCards) - 4):
                        for k in range(j, len(sortedCards) - 4):
                            for l in range(k, len(sortedCards) - 4):
                                for m in range(l, len(sortedCards) - 4):
                                    temp = (sortedCards[i], sortedCards[j + 1], sortedCards[k + 2], sortedCards[l + 3],
                                            sortedCards[m + 4])
                                    if self.isFlush(list(temp)):
                                        if not (self.isStraightFlush(list(temp))):
                                            flush.append(list(temp))
            return flush

        def getFullHouse(self, cardnames):
            sortedCards = self.sortingCards(cardnames)
            fullhouse = []
            if len(sortedCards) >= 5:
                for i in range(len(sortedCards) - 4):
                    for j in range(i, len(sortedCards) - 4):
                        for k in range(j, len(sortedCards) - 4):
                            for l in range(k, len(sortedCards) - 4):
                                for m in range(l, len(sortedCards) - 4):
                                    temp = (sortedCards[i], sortedCards[j + 1], sortedCards[k + 2], sortedCards[l + 3],
                                            sortedCards[m + 4])
                                    if self.isFullHouse(list(temp)):
                                        fullhouse.append(list(temp))
            return fullhouse

        def getFourCardsCombo(self, cardnames):
            sortedCards = self.sortingCards(cardnames)
            fourcards = []
            if len(sortedCards) >= 5:
                for i in range(len(sortedCards) - 4):
                    for j in range(i, len(sortedCards) - 4):
                        for k in range(j, len(sortedCards) - 4):
                            for l in range(k, len(sortedCards) - 4):
                                for m in range(l, len(sortedCards) - 4):
                                    temp = (sortedCards[i], sortedCards[j + 1], sortedCards[k + 2], sortedCards[l + 3],
                                            sortedCards[m + 4])
                                    if self.isFourCards(list(temp)):
                                        fourcards.append(list(temp))
            return fourcards

        def getStraightFlush(self, cardnames):
            sortedCards = self.sortingCards(cardnames)
            straightflush = []
            if len(sortedCards) >= 5:
                for i in range(len(sortedCards) - 4):
                    for j in range(i, len(sortedCards) - 4):
                        for k in range(j, len(sortedCards) - 4):
                            for l in range(k, len(sortedCards) - 4):
                                for m in range(l, len(sortedCards) - 4):
                                    temp = (sortedCards[i], sortedCards[j + 1], sortedCards[k + 2], sortedCards[l + 3],
                                            sortedCards[m + 4])
                                    if self.isStraightFlush(list(temp)):
                                        straightflush.append(list(temp))
            return straightflush

        def anyFlush(self, cardnames):
            countImage = Counter(self.getCardImage(cardnames)).values()
            return any(i >= 5 for i in countImage)

        def getCombo(self, cardnames):
            sortedCards = self.sortingCards(cardnames)
            tris = self.getTris(cardnames)
            fourCards = self.getFourCards(cardnames)
            comboLists = []
            thereFlush = self.anyFlush(cardnames)

            if len(sortedCards) >= 5:
                for i in range(len(sortedCards) - 4):
                    for j in range(i, len(sortedCards) - 4):
                        for k in range(j, len(sortedCards) - 4):
                            for l in range(k, len(sortedCards) - 4):
                                for m in range(l, len(sortedCards) - 4):
                                    temp = [sortedCards[i], sortedCards[j + 1], sortedCards[k + 2], sortedCards[l + 3],
                                            sortedCards[m + 4]]

                                    if len(cardnames) < 15:
                                        if (tris):
                                            # FULLHOUSE
                                            if self.isFullHouse(temp):
                                                comboLists.append(temp)
                                                continue

                                            if (fourCards):
                                                # FOURCARDS
                                                if self.isFourCards(temp):
                                                    comboLists.append(temp)
                                                    continue
                                                    # STRAIGHT
                                        # print("Card: ", self.card, type(self.card))
                                        # print("Temp: ", temp)

                                        if self.isStraight(temp):
                                            if not (self.isStraightFlush(temp)):
                                                comboLists.append(temp)
                                                continue
                                        if thereFlush:
                                            # FLUSH
                                            if self.isFlush(temp):
                                                if not (self.isStraightFlush(temp)):
                                                    comboLists.append(temp)
                                                    continue
                                        if thereFlush:
                                            # STRAIGHTFLUSH
                                            if self.isStraightFlush(temp):
                                                comboLists.append(temp)
            return comboLists

        def getPairScore(self, cardnames):
            return max(self.getCardValues(cardnames))

        def getComboScore(self, cardnames):
            if (self.isStraightFlush(cardnames)):
                if ('2S' in cardnames or '2H' in cardnames or '2C' in cardnames or '2D' in cardnames):
                    if ('AS' in cardnames or 'AH' in cardnames or 'AC' in cardnames or 'AD' in cardnames):
                        sortedCards = self.sortingCards(cardnames)
                        removeTwo = sortedCards[:-2]
                        return (5000 + max(self.getCardValues(removeTwo)))
                    else:
                        sortedCards = self.sortingCards(cardnames)
                        removeOne = sortedCards[:-1]
                        return (5000 + max(self.getCardValues(removeOne)))
                return (5000 + max(self.getCardValues(cardnames)))

            if (self.isFourCards(cardnames)):
                return (4000 + max(self.getCardValues(self.getFourCards(cardnames)[0])))

            if (self.isFullHouse(cardnames)):
                return (3000 + max(self.getCardValues(self.getTris(cardnames)[0])))

            if (self.isFlush(cardnames)):
                if (self.getCardImage(cardnames)[0] == "D"): return (2000 + max(self.getCardValues(cardnames)))
                if (self.getCardImage(cardnames)[0] == "C"): return (2250 + max(self.getCardValues(cardnames)))
                if (self.getCardImage(cardnames)[0] == "H"): return (2500 + max(self.getCardValues(cardnames)))
                if (self.getCardImage(cardnames)[0] == "S"): return (2750 + max(self.getCardValues(cardnames)))

            if (self.isStraight(cardnames)):
                if ('2S' in cardnames or '2H' in cardnames or '2C' in cardnames or '2D' in cardnames):
                    if ('AS' in cardnames or 'AH' in cardnames or 'AC' in cardnames or 'AD' in cardnames):
                        sortedCards = self.sortingCards(cardnames)
                        removeTwo = sortedCards[:-2]
                        return (1000 + max(self.getCardValues(removeTwo)))
                    else:
                        sortedCards = self.sortingCards(cardnames)
                        removeOne = sortedCards[:-1]
                        return (1000 + max(self.getCardValues(removeOne)))
                return (1000 + max(self.getCardValues(cardnames)))
    card = Card()

    class Logic:
        def __init__(self, card_instance):
            self.card = card_instance

        # card1 = hand
        # card2 = field
        def higherSingle(self, card1, card2):
            return (self.card.getCardValues(card1)[0] - self.card.getCardValues(card2)[0]) > 0

        def higherPair(self, cards1, cards2):
            return (self.card.getPairScore(cards1) - self.card.getPairScore(cards2)) > 0

        def higherCombo(self, cards1, cards2):
            return (self.card.getComboScore(cards1) - self.card.getComboScore(cards2)) > 0

        def legalCard(self, cards):
            return (self.card.isSingle(cards) or self.card.isPair(cards) or self.card.isCombo(cards))

        def legalFirstMove(self, cards):
            if (self.legalCard(cards)):
                hand = self.card.sortingCards(cards)
                return hand[0] == '3D'
            return False

        def legalMove(self, cards, field):
            if (self.legalCard(cards) and self.legalCard(field)):
                if (self.card.isSingle(cards) and self.card.isSingle(field)):
                    return self.higherSingle(cards, field)
                if (self.card.isPair(cards) and self.card.isPair(field)):
                    return self.higherPair(cards, field)
                if (self.card.isCombo(cards) and self.card.isCombo(field)):
                    return self.higherCombo(cards, field)

        def possibleMoves(self, hand, field, control, turn):
            moveLists = []
            if control == True:

                [moveLists.append([x]) for x in hand]

                pairLists = self.card.getPair(hand)
                if pairLists:
                    [moveLists.append(x) for x in pairLists]

                comboLists = self.card.getCombo(hand)
                # print(f"Card Here: {self.card}, Card Type: {type(self.card)}")
                if comboLists:
                    [moveLists.append(x) for x in comboLists]
                if turn == 0:
                    moveLists = [x for x in moveLists if '3D' in x]
                return moveLists

            if len(field) == 1:
                for _ in hand:
                    single = [_]
                    if self.higherSingle(single, field):
                        moveLists.append(single)

            if len(field) == 2:
                pairLists = self.card.getPair(hand)
                if pairLists:
                    if len(pairLists) > 0:
                        for _ in pairLists:
                            if self.higherPair(_, field):
                                moveLists.append(_)

            if len(field) == 5:
                comboLists = self.card.getCombo(hand)
                if comboLists:
                    if len(comboLists) > 0:
                        for _ in comboLists:
                            if self.higherCombo(_, field):
                                moveLists.append(_)

            moveLists.append([])
            return moveLists

    logic = Logic(card)
    class RulesAgent():
        def __init__(self, card_instance, logic_instance):
            self.card = card_instance
            self.logic = logic_instance

        def enemyProbably(self, hand, field_history):
            allcards = [d['name'] for d in self.card.card]
            unseen = list(set(allcards).difference(set(hand).union(set(field_history))))
            enemyLists = []
            # Single
            [enemyLists.append([x]) for x in unseen]
            # Pair
            pairLists = self.card.getPair(unseen)
            if pairLists:
                [enemyLists.append(x) for x in pairLists]
            if len(unseen) > 15:
                tempUnseen = self.card.sortingCards(unseen)
                tempUnseen = tempUnseen[-15:]
                comboLists = self.card.getCombo(tempUnseen)
            else:
                comboLists = self.card.getCombo(unseen)
            if comboLists:
                [enemyLists.append(x) for x in comboLists]
            return enemyLists

        def findMaxValue(self, hand):
            value = []
            for cards in hand:
                value.append(max(self.card.getCardValues(cards)))
            return max(value)

        def comboSelection(self, hand):
            tempCombo = self.card.getCombo(hand)
            comboCombination = []
            for combo in tempCombo:
                otherCombo = self.card.getCombo(list(set(hand).difference(set(combo))))
                if otherCombo:
                    for oCombo in otherCombo:
                        comboCombination.append([combo, oCombo])
            if len(comboCombination) == 0:
                comboCombination = tempCombo

            handLeft = []
            selectedCombo = []
            if len(comboCombination) > 0:
                for combo in comboCombination:
                    if len(combo) == 2:
                        cardLeft = [x for x in hand if x not in combo[0] and x not in combo[1]]

                        trisCard = self.card.getTris(cardLeft)
                        if len(selectedCombo) == 0:
                            if trisCard:
                                usedCard = []
                                for tris in trisCard:
                                    handLeft.append(tris)
                                    for _ in tris:
                                        usedCard.append(_)

                                cardLeft = [x for x in cardLeft if x not in usedCard]

                            pairCard = self.card.getPair(cardLeft)
                            if pairCard:
                                usedCard = []
                                for pair in pairCard:
                                    handLeft.append(pair)
                                    for _ in pair:
                                        usedCard.append(_)

                                cardLeft = [x for x in cardLeft if x not in usedCard]

                            for _ in cardLeft:
                                handLeft.append([_])

                            selectedCombo = combo

                        elif len(selectedCombo) > 0:
                            tempHandLeft = []
                            if trisCard:
                                usedCard = []
                                for tris in trisCard:
                                    tempHandLeft.append(tris)
                                    for _ in tris:
                                        usedCard.append(_)

                                cardLeft = [x for x in cardLeft if x not in usedCard]

                            pairCard = self.card.getPair([x for x in cardLeft])
                            if pairCard:
                                usedCard = []
                                for pair in pairCard:
                                    tempHandLeft.append(pair)
                                    for _ in pair:
                                        usedCard.append(_)

                                cardLeft = [x for x in cardLeft if x not in usedCard]

                            for _ in cardLeft:
                                tempHandLeft.append([_])

                            tempHandLeftScore = 0 if tempHandLeft == [] else self.findMaxValue(tempHandLeft)
                            handLeftScore = 0 if handLeft == [] else self.findMaxValue(handLeft)

                            selectedComboScore = [self.card.getComboScore(selectedCombo[0]),
                                                  self.card.getComboScore(selectedCombo[1])]
                            tempComboScore = [self.card.getComboScore(combo[0]), self.card.getComboScore(combo[1])]

                            if handLeftScore < tempHandLeftScore:
                                handLeft = tempHandLeft
                                selectedCombo = combo

                            elif handLeftScore == tempHandLeftScore:
                                if len(handLeft) > len(tempHandLeft):
                                    handLeft = tempHandLeft
                                    selectedCombo = combo

                                elif len(handLeft) == len(tempHandLeft):
                                    if max(selectedComboScore) + 250 < max(tempComboScore):
                                        handLeft = tempHandLeft
                                        selectedCombo = combo

                    elif len(combo) == 5:
                        cardLeft = [x for x in hand if x not in combo]
                        fourCard = self.card.getFourCards(cardLeft)

                        if len(selectedCombo) == 0:
                            if fourCard:
                                usedCard = []
                                for four in fourCard:
                                    handLeft.append(four)
                                    for _ in four:
                                        usedCard.append(_)

                                cardLeft = [x for x in cardLeft if x not in usedCard]

                            trisCard = self.card.getTris(cardLeft)
                            if trisCard:
                                usedCard = []
                                for tris in trisCard:
                                    handLeft.append(tris)
                                    for _ in tris:
                                        usedCard.append(_)

                                cardLeft = [x for x in cardLeft if x not in usedCard]

                            pairCard = self.card.getPair(cardLeft)
                            if pairCard:
                                usedCard = []
                                for pair in pairCard:
                                    handLeft.append(pair)
                                    for _ in pair:
                                        usedCard.append(_)

                                cardLeft = [x for x in cardLeft if x not in usedCard]

                            for _ in cardLeft:
                                handLeft.append([_])

                            selectedCombo = [combo]

                        elif len(selectedCombo) > 0:
                            tempHandLeft = []
                            if fourCard:
                                usedCard = []
                                for four in fourCard:
                                    tempHandLeft.append(four)
                                    for _ in four:
                                        usedCard.append(_)

                                cardLeft = [x for x in cardLeft if x not in usedCard]

                            trisCard = self.card.getTris(cardLeft)
                            if trisCard:
                                usedCard = []
                                for tris in trisCard:
                                    tempHandLeft.append(tris)
                                    for _ in tris:
                                        usedCard.append(_)

                                cardLeft = [x for x in cardLeft if x not in usedCard]

                            pairCard = self.card.getPair([x for x in cardLeft])
                            if pairCard:
                                usedCard = []
                                for pair in pairCard:
                                    tempHandLeft.append(pair)
                                    for _ in pair:
                                        usedCard.append(_)

                                cardLeft = [x for x in cardLeft if x not in usedCard]

                            for _ in cardLeft:
                                tempHandLeft.append([_])

                            tempHandLeftScore = 0 if tempHandLeft == [] else self.findMaxValue(tempHandLeft)
                            handLeftScore = 0 if handLeft == [] else self.findMaxValue(handLeft)

                            selectedComboScore = self.card.getComboScore(selectedCombo[0])
                            tempComboScore = self.card.getComboScore(combo)

                            if handLeftScore < tempHandLeftScore:
                                handLeft = tempHandLeft
                                selectedCombo = [combo]

                            elif handLeftScore == tempHandLeftScore:
                                if len(handLeft) > len(tempHandLeft):
                                    handLeft = tempHandLeft
                                    selectedCombo = [combo]

                                elif len(handLeft) == len(tempHandLeft):
                                    if selectedComboScore + 250 < tempComboScore:
                                        handLeft = tempHandLeft
                                        selectedCombo = [combo]

            return selectedCombo

        def cardClassifier(self, hand, field_history, min_hand):
            probCards = self.enemyProbably(hand, field_history)
            probSingle = []
            probPair = []
            probCombo = []
            classASP = []
            classA = []
            classB = []
            classC = []
            classD = []
            for i in probCards:
                if len(i) == 1:
                    probSingle.append(i[0])
                if len(i) == 2:
                    probPair.append(i)
                if len(i) == 5:
                    probCombo.append(i)

            # find max and min single
            probSingle = self.card.sortingCards(probSingle)
            maxSingle = max(self.card.getCardValues(probSingle))
            minSingle = min(self.card.getCardValues(probSingle))
            divSingleIndex = int(len(probSingle) * 0.8)
            divSingle = self.card.getCardValues(probSingle)[divSingleIndex]

            # find max and min pair
            if len(probPair) > 0:
                sortedPair = self.card.sortingPairs(probPair)
                pairScore = [self.card.getPairScore(x) for x in sortedPair]
                maxPair = max(pairScore)
                minPair = min(pairScore)
                divPairIndex = int(len(sortedPair) * 0.7)
                divPair = self.card.getPairScore(sortedPair[divPairIndex])

            # find max and min combo
            maxCombo = 3034
            minCombo = 1029
            divCombo = 2500
            if len(probCombo) > 0:
                tempCombo = probCombo
                sortedCombo = []
                for i in range(len(probCombo)):
                    scoreCombo = [self.card.getComboScore(x) for x in tempCombo]
                    index = scoreCombo.index(min(scoreCombo))
                    lowestCombo = tempCombo[index]
                    sortedCombo.append(lowestCombo)
                    tempCombo = tempCombo[:index] + tempCombo[index + 1:]

                comboScore = [self.card.getComboScore(x) for x in sortedCombo]
                maxCombo = max(comboScore)
                minCombo = min(comboScore)
                divComboIndex = int(len(sortedCombo) * 0.7)
                divCombo = self.card.getComboScore(sortedCombo[divComboIndex])

            # ASP = A single or A pair
            for i in hand:
                value = self.card.getCardValues([i])[0]
                # find classA single
                if value > maxSingle:
                    classA.append([i])
                    classASP.append(i)
                # find classB single
                if value > divSingle and value < maxSingle:
                    classB.append([i])
                # find classC single
                if value <= divSingle and value > minSingle:
                    classC.append([i])
                # find classD single
                if value < minSingle:
                    classD.append([i])

            pairs = []
            pairLists = self.card.getPair(hand)
            if pairLists:
                [pairs.append(x) for x in pairLists]
                pairs = self.card.sortingPairs(pairs)

            if len(probPair) > 0:
                for i in pairs:
                    value = self.card.getPairScore(i)
                    # find classA pair
                    if value > maxPair:
                        classA.append(i)
                        classASP.append(i[0])
                        classASP.append(i[1])
                    # find classB pair
                    if value > divPair and value < maxPair:
                        classB.append(i)
                    # find classC pair
                    if value <= divPair and value > minPair:
                        classC.append(i)
                    # find classD pair
                    if value < minPair:
                        classD.append(i)
            elif len(probPair) == 0:
                for i in pairs:
                    classA.append(i)
                    classASP.append(i[0])
                    classASP.append(i[1])

            classASP = list(set(classASP))
            combos = []
            comboLists = self.comboSelection(hand)
            if comboLists:
                [combos.append(x) for x in comboLists]

            for i in combos:
                value = self.card.getComboScore(i)
                # find classA combo
                if value > maxCombo:
                    classA.append(i)
                # find classB combo
                if value > divCombo and value < maxCombo:
                    classB.append(i)
                # find classC combo
                if value <= divCombo and value > minCombo:
                    classC.append(i)
                # find classD pair
                if value < minCombo:
                    classD.append(i)

            return {'classA': classA,
                    'classB': classB,
                    'classC': classC,
                    'classD': classD}

        def twoCard(self, hand, classA, enemy1, enemy2, enemy3):
            handPair = self.card.getPair(hand)
            if handPair:
                return handPair[0]
            elif classA or (1 in [enemy1, enemy2, enemy3]):
                return [hand[1]]
            return [hand[0]]

        def threeCard(self, hand, classA, classB, classC, classD, enemy1, enemy2, enemy3):
            handPair = self.card.getFixPair(hand)
            if handPair:
                filterSingle = [[x] for x in hand if not (any(x in Pair for Pair in handPair))]
                if classA:
                    # 1 pair in class A
                    if handPair[0] in classA:
                        return handPair[0]
                        # single cards in class A
                    elif filterSingle[0] in classA:
                        return filterSingle[0]
                # If opponent single, play pair
                elif 1 in [enemy1, enemy2, enemy3]:
                    return handPair[0]
                # If opponent 2 cards, play single
                elif 2 in [enemy1, enemy2, enemy3]:
                    return filterSingle[0]
                else:
                    if classD: return classD[0]
                    if classC: return classC[0]
                    if classB: return classB[0]
                    if classA: return classA[0]
                    # All single cards
            else:
                if 1 in [enemy1, enemy2, enemy3]:
                    if classA:
                        if hand[2] in classA:
                            return [hand[1]]
                        return [hand[2]]
                    return [hand[2]]
                elif classA:
                    if hand[2] in classA:
                        return [hand[1]]
                    return [hand[0]]
                return [hand[0]]

        # Four cards left
        def fourCard(self, hand, classA, classB, classC, classD, enemy1, enemy2, enemy3):
            # Check pair
            handPair = self.card.getFixPair(hand)
            if handPair:
                # Double pairs
                if len(handPair) == 2:
                    sortedPair = self.card.sortingPairs(handPair)
                    if classA:
                        if sortedPair[1] in classA:
                            return sortedPair[1]
                        return sortedPair[0]
                    elif 2 in [enemy1, enemy2, enemy3]:
                        return sortedPair[1]
                    return sortedPair[0]
                # One pair
                elif len(handPair) == 1:
                    filterSingle = [[x] for x in hand if not (any(x in Pair for Pair in handPair))]
                    if classA:
                        # single cards in class A
                        if filterSingle[1] in classA:
                            return filterSingle[0]
                        # If enemy single, play pair
                        elif 1 in [enemy1, enemy2, enemy3]:
                            return handPair[0]
                        # If enemy 2 cards, play single
                        elif 2 in [enemy1, enemy2, enemy3]:
                            return filterSingle[0]
                        return filterSingle[1]
                    else:
                        if classD: return classD[0]
                        if classC: return classC[0]
                        if classB: return classB[0]
                        if classA: return classA[0]
            # All single cards
            else:
                if classA:
                    return [hand[1]]
                elif 1 in [enemy1, enemy2, enemy3]:
                    return [hand[3]]
                return [hand[0]]

        # Cards left <= 4
        def underFour(self, hand, classA, classB, classC, classD, enemy1, enemy2, enemy3):
            if len(hand) == 2:
                return self.twoCard(hand, classA, enemy1, enemy2, enemy3)
            elif len(hand) == 3:
                return self.threeCard(hand, classA, classB, classC, classD, enemy1, enemy2, enemy3)
            elif len(hand) == 4:
                return self.fourCard(hand, classA, classB, classC, classD, enemy1, enemy2, enemy3)
            return [hand[0]]

        # Cards left > 4
        def overFour(self, hand, classA, classB, classC, classD, enemy1, enemy2, enemy3):
            comboCard = self.findComboInClass(classD) + self.findComboInClass(classC) + self.findComboInClass(
                classB) + self.findComboInClass(
                classA)
            pairCard = self.findPairInClass(classD) + self.findPairInClass(classC) + self.findPairInClass(
                classB) + self.findPairInClass(classA)
            singleCard = self.findSingleInClass(classD) + self.findSingleInClass(classC) + self.findSingleInClass(
                classB) + self.findSingleInClass(
                classA)
            if 1 in [enemy1, enemy2, enemy3]:
                if comboCard:
                    return comboCard[0]
                elif pairCard:
                    return pairCard[0]
                else:
                    if classD: return classD[0]
                    if classC: return classC[0]
                    if classB: return classB[0]
                    if classA: return classA[0]
            else:
                if (not comboCard) and (len(pairCard) > len(singleCard)):
                    return pairCard[0]
                else:
                    if classD: return classD[0]
                    if classC: return classC[0]
                    if classB: return classB[0]
                    if classA: return classA[0]

        def checkHoldback(self, hand, field, enemy1, enemy2, enemy3, turn, pass_turn, classA, classB, classC, classD,
                          selected_card):
            # Holdback Single
            if len(field) == 1:
                if len(hand) <= 2:
                    return False
                if min(enemy1, enemy2, enemy3) <= 2 and selected_card == [hand[-1]]:
                    return False
                if len(classA) < (len(classB) + len(classC) + len(classD)):
                    if selected_card == [hand[-1]]:
                        return True
                if min([len(hand), enemy1, enemy2, enemy3]) > 6:
                    if selected_card == [hand[-1]]:
                        return True
            # Holdback Pair
            if len(field) == 2:
                if len(hand) <= 3:
                    return False
                if min([len(hand), enemy1, enemy2, enemy3]) > 2:
                    if self.card.getPairScore(selected_card) >= 50:
                        return True
            # Holdback Combo
            if len(field) == 5:
                if len(hand) == 5:
                    return False
                if min([len(hand), enemy1, enemy2, enemy3]) > 6 and turn <= 4:
                    # Check any enemy pass
                    # If an enemy has passed a 5 hand trick this early in the game, likely they are holding onto theirs
                    if 1 in pass_turn.values():
                        # Check any combo from self.card left
                        cardLeft = list(set(hand).difference(set(selected_card)))
                        tempCombo = self.card.getCombo(cardLeft)
                        if len(tempCombo) > 0 and (selected_card in classA or selected_card in classB):
                            return True
            return False

        def findSingleInClass(self, className):
            return [x for x in className if len(x) == 1]

        def findPairInClass(self, className):
            return [x for x in className if len(x) == 2]

        def findComboInClass(self, className):
            return [x for x in className if len(x) == 5]

        def splitTrisToSingleAndPair(self, className):
            splitedPair = []
            splitedSingle = []
            pairCards = []
            trisCards = []
            pairs = self.findPairInClass(className)
            if pairs:
                for pair in pairs:
                    pairCards.append(pair[0])
                    pairCards.append(pair[1])
                pairCards = self.card.sortingCards(list(set(pairCards)))

                trisInClass = self.card.getTris(pairCards)
                if trisInClass:
                    for tris in trisInClass:
                        trisCards.append(tris[0])
                        trisCards.append(tris[1])
                        trisCards.append(tris[2])
                        splitedPair.append(tris[0:2])
                        splitedSingle.append([tris[2]])

                    pairFromTris = self.card.getPair(trisCards)
                    classResult = [x for x in className if x not in pairFromTris]
                    for x in splitedPair: classResult.append(x)
                    for x in splitedSingle: classResult.append(x)
                    return classResult
            return className

        def maxPairInCombo(self, comboCard):
            # Pair in two combo
            if (self.card.isFourCards(comboCard[0]) or self.card.isFullHouse(comboCard[0])) and (
                    self.card.isFourCards(comboCard[1]) or self.card.isFullHouse(comboCard[1])):
                tempCard1 = comboCard[0]
                tempPair1 = self.card.getPair(tempCard1)
                tempCombo1 = [self.card.getPairScore(x) for x in tempPair1]
                tempCard2 = comboCard[1]
                tempPair2 = self.card.getPair(tempCard2)
                tempCombo2 = [self.card.getPairScore(x) for x in tempPair2]
                if max(tempCombo1) > max(tempCombo2):
                    return [comboCard[0]]
                return [comboCard[1]]
            # Pair only in one combo
            else:
                if self.card.isFourCards(comboCard[0]) or self.card.isFullHouse(comboCard[0]):
                    return [comboCard[0]]
                return [comboCard[1]]

        def splitComboToPair(self, comboCard):
            splitResult = []
            # Four cards
            if self.card.isFourCards(comboCard[0]):
                fourInCombo = self.card.getFourCards(comboCard[0])
                for x in fourInCombo:
                    splitResult.append(x[0:2])
                    splitResult.append(x[2:4])
            # Full house
            elif self.card.isFullHouse(comboCard[0]):
                trisInCombo = self.card.getTris(comboCard[0])
                splitResult.append([x for x in comboCard[0] if x not in trisInCombo[0]])
                for x in trisInCombo:
                    splitResult.append(x[0:2])
                splitResult = self.card.sortingPairs(splitResult)
            # Straight, Flush, and Straight Flush
            else:
                splitResult = []
            return splitResult

        def pairInCombo(self, comboCard, moveLists, enemy1, enemy2, enemy3):
            # Double combo
            if len(comboCard) == 2:
                if (self.card.isFourCards(comboCard[0]) or self.card.isFullHouse(comboCard[0])) or (
                        self.card.isFourCards(comboCard[1]) or self.card.isFullHouse(comboCard[1])):
                    comboCard = self.maxPairInCombo(comboCard)
                    splitResult = self.splitComboToPair(comboCard)
                    if 2 in [enemy1, enemy2, enemy3]:
                        for cards in reversed(splitResult):
                            if cards in moveLists: return cards
                        return []
                    else:
                        for cards in splitResult:
                            if cards in moveLists: return cards
                        return []
                return []
            # Single combo
            if len(comboCard) == 1:
                if (self.card.isFourCards(comboCard[0]) or self.card.isFullHouse(comboCard[0])):
                    comboCard = [comboCard[0]]
                    splitResult = self.splitComboToPair(comboCard)
                    if 2 in [enemy1, enemy2, enemy3]:
                        for cards in reversed(splitResult):
                            if cards in moveLists: return cards
                        return []
                    else:
                        for cards in splitResult:
                            if cards in moveLists: return cards
                        return []
                return []

        def maxSingleInCombo(self, comboCard):
            tempCombo1 = [self.card.getCardValues([x]) for x in comboCard[0]]
            tempCombo2 = [self.card.getCardValues([x]) for x in comboCard[1]]
            if max(tempCombo1) > max(tempCombo2):
                return [comboCard[0]]
            return [comboCard[1]]

        def splitComboToSingle(self, comboCard):
            return [[x] for x in comboCard[0]]

        def singleInCombo(self, comboCard, moveLists, enemy1, enemy2, enemy3):
            if len(comboCard) == 2:
                comboCard = self.maxSingleInCombo(comboCard)
            splitResult = self.splitComboToSingle(comboCard)
            if 1 in [enemy1, enemy2, enemy3]:
                for cards in reversed(splitResult):
                    if cards in moveLists: return cards
                return []
            else:
                for cards in splitResult:
                    if cards in moveLists: return cards
                return []

        def splitPairToSingle(self, pairCard):
            return [[x] for x in pairCard[-1]]

        def splitMove(self, field, moveLists, comboCard, pairCard, singleCard, enemy1, enemy2, enemy3):
            # # Field combo
            if len(field) == 5:
                if comboCard:
                    for cards in comboCard:
                        if cards in moveLists: return cards
                    return []
                return []
            # Field pair
            if len(field) == 2:
                if pairCard:
                    if 2 in [enemy1, enemy2, enemy3]:
                        for cards in reversed(pairCard):
                            if cards in moveLists: return cards
                        else:
                            # Split combo
                            if comboCard:
                                return self.pairInCombo(comboCard, moveLists, enemy1, enemy2, enemy3)
                            return []
                    else:
                        for cards in pairCard:
                            if cards in moveLists: return cards
                        else:
                            # Split combo
                            if comboCard:
                                return self.pairInCombo(comboCard, moveLists, enemy1, enemy2, enemy3)
                            return []
                else:
                    # Split combo
                    if comboCard:
                        return self.pairInCombo(comboCard, moveLists, enemy1, enemy2, enemy3)
                    return []
                    # Field single
            if len(field) == 1:
                if singleCard:
                    for cards in reversed(singleCard):
                        if cards in moveLists: return cards
                    else:
                        # Split pair
                        if pairCard:
                            splitResult = self.splitPairToSingle(pairCard)
                            for cards in splitResult:
                                if cards in moveLists: return cards
                            else:
                                # Split combo
                                if comboCard:
                                    return self.singleInCombo(comboCard, moveLists, enemy1, enemy2, enemy3)
                                return []
                        # Split combo
                        if comboCard:
                            return self.singleInCombo(comboCard, moveLists, enemy1, enemy2, enemy3)
                        return []
                else:
                    # Split pair
                    if pairCard:
                        splitResult = self.splitPairToSingle(pairCard)
                        for cards in splitResult:
                            if cards in moveLists: return cards
                        else:
                            # Split combo
                            if comboCard:
                                return self.singleInCombo(comboCard, moveLists, enemy1, enemy2, enemy3)
                            return []
                    # Split combo
                    if comboCard:
                        return self.singleInCombo(comboCard, moveLists, enemy1, enemy2, enemy3)
                    return []

        def notControlMove(self, field, moveLists, comboCard, pairCard, singleCard, enemy1, enemy2, enemy3):
            # Field Combo
            if len(field) == 5:
                if comboCard:
                    for cards in comboCard:
                        if cards in moveLists: return cards
                    return []
                return []
            # Field pair
            if len(field) == 2:
                if pairCard:
                    if 2 in [enemy1, enemy2, enemy3]:
                        for cards in reversed(pairCard):
                            if cards in moveLists: return cards
                        return []
                    else:
                        for cards in pairCard:
                            if cards in moveLists: return cards
                        return []
                return []
                # Field single
            if len(field) == 1:
                if singleCard:
                    for cards in reversed(singleCard):
                        if cards in moveLists: return cards
                    return []
                return []

        def advanceStrategy(self, hand, field, moveLists, pass_turn, classA, classB, classC, classD, enemy1, enemy2,
                            enemy3,
                            control,
                            moveLen):
            classASingle = self.findSingleInClass(classA)
            classAPair = self.findPairInClass(classA)
            classACombo = self.findComboInClass(classA)

            classBSingle = self.findSingleInClass(classB)
            classBPair = self.findPairInClass(classB)
            classBCombo = self.findComboInClass(classB)

            classCSingle = self.findSingleInClass(classC)
            classCPair = self.findPairInClass(classC)
            classCCombo = self.findComboInClass(classC)

            classDSingle = self.findSingleInClass(classD)
            classDPair = self.findPairInClass(classD)
            classDCombo = self.findComboInClass(classD)

            comboCard = classDCombo + classCCombo + classBCombo + classACombo
            pairCard = classDPair + classCPair + classBPair + classAPair
            singleCard = classDSingle + classCSingle + classBSingle + classASingle

            if moveLen <= 2:
                if control:
                    if len(classA) > 0:
                        return classA[0]
                    else:
                        if comboCard:
                            return comboCard[0]
                        if pairCard:
                            if 2 in [enemy1, enemy2, enemy3]:
                                return pairCard[-1]
                            return pairCard[0]
                        if singleCard:
                            return singleCard[-1]
                        return []

                if not control:
                    if min(enemy1, enemy2, enemy3) <= 2:
                        return self.splitMove(field, moveLists, comboCard, pairCard, singleCard, enemy1, enemy2, enemy3)
                    # Opponent cards > 2
                    else:
                        return self.notControlMove(field, moveLists, comboCard, pairCard, singleCard, enemy1, enemy2,
                                                   enemy3)

            if moveLen == 3:
                if control:
                    if len(classA) > 1:
                        return classA[0]
                    else:
                        if comboCard:
                            return comboCard[0]
                        if pairCard:
                            if 2 in [enemy1, enemy2, enemy3]:
                                return pairCard[-1]
                            return pairCard[0]
                        if singleCard:
                            return singleCard[-1]
                        return []

                if not control:
                    if min(enemy1, enemy2, enemy3) <= 2:
                        return self.splitMove(field, moveLists, comboCard, pairCard, singleCard, enemy1, enemy2, enemy3)
                    # Opponent cards > 2
                    else:
                        return self.notControlMove(field, moveLists, comboCard, pairCard, singleCard, enemy1, enemy2,
                                                   enemy3)

        def moveSelection(self, hand, field, turn, pass_turn, classA, classB, classC, classD, enemy1, enemy2, enemy3,
                          control,
                          cardClass, moveLists):
            classAlen = len(classA)
            classBlen = len(classB)
            classClen = len(classC)
            classDlen = len(classD)

            tempClassA = classA
            tempClassB = classB
            tempClassC = classC
            tempClassD = classD

            moveLen = classAlen + classBlen + classClen + classDlen
            if moveLen <= 3 and len(hand) > 4:
                return self.advanceStrategy(hand, field, moveLists, pass_turn, classA, classB, classC, classD, enemy1,
                                            enemy2,
                                            enemy3, control, moveLen)

            if turn == 0:
                classA = [x for x in classA if x in moveLists]
                classB = [x for x in classB if x in moveLists]
                classC = [x for x in classC if x in moveLists]
                classD = [x for x in classD if x in moveLists]
                if classD: return classD[0]
                if classC: return classC[0]
                if classB: return classB[0]
                if classA: return classA[0]

            if classAlen > (classClen + classDlen + classBlen) and classAlen > 0:
                classA = [x for x in classA if x in moveLists]
                if classA: return classA[0]

            if control:
                if len(hand) <= 4:
                    selected_card = self.underFour(hand, classA, classB, classC, classD, enemy1, enemy2, enemy3)
                    return selected_card
                else:
                    selected_card = self.overFour(hand, classA, classB, classC, classD, enemy1, enemy2, enemy3)
                    return selected_card

            if not control:

                if len(field) == 1:
                    bigPair = self.findPairInClass(classA)
                    if bigPair:
                        bigSingle = bigPair[-1]
                        classA.append([bigSingle[0]])
                        classA.append([bigSingle[1]])

                classA = [x for x in classA if x in moveLists]
                classB = [x for x in classB if x in moveLists]
                classC = [x for x in classC if x in moveLists]
                classD = [x for x in classD if x in moveLists]

                if 1 in [enemy1, enemy2, enemy3]:
                    comboCard = self.findComboInClass(classD) + self.findComboInClass(classC) + self.findComboInClass(
                        classB) + self.findComboInClass(classA)
                    pairCard = self.findPairInClass(classD) + self.findPairInClass(classC) + self.findPairInClass(
                        classB) + self.findPairInClass(
                        classA)
                    singleCard = self.findSingleInClass(classD) + self.findSingleInClass(
                        classC) + self.findSingleInClass(
                        classB) + self.findSingleInClass(classA)
                    return self.splitMove(field, moveLists, comboCard, pairCard, singleCard, enemy1, enemy2, enemy3)
                if classD:
                    for selected_card in classD:
                        if not self.checkHoldback(hand, field, enemy1, enemy2, enemy3, turn, pass_turn, tempClassA,
                                                  tempClassB,
                                                  tempClassC, tempClassD, selected_card):
                            return selected_card
                if classC:
                    for selected_card in classC:
                        if not self.checkHoldback(hand, field, enemy1, enemy2, enemy3, turn, pass_turn, tempClassA,
                                                  tempClassB,
                                                  tempClassC, tempClassD, selected_card):
                            return selected_card
                if classB:
                    for selected_card in classB:
                        if not self.checkHoldback(hand, field, enemy1, enemy2, enemy3, turn, pass_turn, tempClassA,
                                                  tempClassB,
                                                  tempClassC, tempClassD, selected_card):
                            return selected_card
                if classA:
                    for selected_card in classA:
                        if not self.checkHoldback(hand, field, enemy1, enemy2, enemy3, turn, pass_turn, tempClassA,
                                                  tempClassB,
                                                  tempClassC, tempClassD, selected_card):
                            return selected_card
                return []

        def predictedMove(self, hand, field, control, turn, field_history, enemy1, enemy2, enemy3, pass_turn):
            if type(hand) != list:
                hand = hand.translate({ord('"'): None})
                hand = hand.translate({ord(']'): None})
                hand = hand.translate({ord('['): None})
                hand = hand.translate({ord("'"): None})
                hand = hand.translate({ord(' '): None})
                hand = hand.split(",")

            if type(field) != list:
                if field == "[',']":
                    field = []
                else:
                    field = field.translate({ord('"'): None})
                    field = field.translate({ord(']'): None})
                    field = field.translate({ord('['): None})
                    field = field.translate({ord("'"): None})
                    field = field.translate({ord(' '): None})
                    field = field.split(",")

            if type(field_history) != list:
                if field_history == "[',']":
                    field_history = []
                else:
                    field_history = field_history.translate({ord('"'): None})
                    field_history = field_history.translate({ord(']'): None})
                    field_history = field_history.translate({ord('['): None})
                    field_history = field_history.translate({ord("'"): None})
                    field_history = field_history.translate({ord(' '): None})
                    field_history = field_history.split(",")

            if type(pass_turn) != list and type(pass_turn) != dict:
                pass_turn = pass_turn.translate({ord('"'): None})
                pass_turn = pass_turn.translate({ord(']'): None})
                pass_turn = pass_turn.translate({ord('['): None})
                pass_turn = pass_turn.translate({ord("'"): None})
                pass_turn = pass_turn.translate({ord(' '): None})
                pass_turn = pass_turn.split(",")
                pass_turn = {0: int(pass_turn[0]),
                             1: int(pass_turn[1]),
                             2: int(pass_turn[2]),
                             3: int(pass_turn[3])}

            if control == "true" or control == "True":
                control = True
            elif control == "false" or control == "False":
                control = False



            moveLists = self.logic.possibleMoves(hand, field, control, turn)
            if len(moveLists) == 0:
                return []
            min_enemy = min([enemy1, enemy2, enemy3])
            cardClass = self.cardClassifier(hand, field_history, min_enemy)
            classA = cardClass['classA']
            classB = cardClass['classB']
            classC = cardClass['classC']
            classD = cardClass['classD']

            filterClassA = [x for x in classA]
            filterClassB = [x for x in classB]
            filterClassC = [x for x in classC]
            filterClassD = [x for x in classD]

            # print(f"filterClassA: {filterClassA}")
            # print(f"filterClassB: {filterClassB}")
            # print(f"filterClassC: {filterClassC}")
            # print(f"filterClassD: {filterClassD}")

            classASingle = self.findSingleInClass(filterClassA)
            classAPair = self.findPairInClass(filterClassA)
            classACombo = self.findComboInClass(filterClassA)

            classBSingle = self.findSingleInClass(filterClassB)
            classBPair = self.findPairInClass(filterClassB)
            classBCombo = self.findComboInClass(filterClassB)

            classCSingle = self.findSingleInClass(filterClassC)
            classCPair = self.findPairInClass(filterClassC)
            classCCombo = self.findComboInClass(filterClassC)

            classDSingle = self.findSingleInClass(filterClassD)
            classDPair = self.findPairInClass(filterClassD)
            classDCombo = self.findComboInClass(filterClassD)

            if len(classASingle) >= (len(classCSingle) + len(classDSingle)) and len(classASingle) >= len(
                    classBSingle) and (
                    len(filterClassB) + len(filterClassC) + len(filterClassD)) > 0 and (
                    len(filterClassB) + len(filterClassC) + len(filterClassD)) < len(filterClassA):
                filterClassA = classASingle
                filterClassB = classBSingle
                filterClassC = classCSingle
                filterClassD = classDSingle

            else:
                if len(hand) >= 4:
                    classAPair = [x for x in classAPair if not (any(x[0] in Combo for Combo in classDCombo)) and not (
                        any(x[1] in Combo for Combo in classDCombo))
                                  and not (any(x[0] in Combo for Combo in classCCombo)) and not (
                        any(x[1] in Combo for Combo in classCCombo))
                                  and not (any(x[0] in Combo for Combo in classBCombo)) and not (
                        any(x[1] in Combo for Combo in classBCombo))
                                  and not (any(x[0] in Combo for Combo in classACombo)) and not (
                        any(x[1] in Combo for Combo in classACombo))]

                    classBPair = [x for x in classBPair if not (any(x[0] in Combo for Combo in classDCombo)) and not (
                        any(x[1] in Combo for Combo in classDCombo))
                                  and not (any(x[0] in Combo for Combo in classCCombo)) and not (
                        any(x[1] in Combo for Combo in classCCombo))
                                  and not (any(x[0] in Combo for Combo in classBCombo)) and not (
                        any(x[1] in Combo for Combo in classBCombo))
                                  and not (any(x[0] in Combo for Combo in classACombo)) and not (
                        any(x[1] in Combo for Combo in classACombo))]

                    classCPair = [x for x in classCPair if not (any(x[0] in Combo for Combo in classDCombo)) and not (
                        any(x[1] in Combo for Combo in classDCombo))
                                  and not (any(x[0] in Combo for Combo in classCCombo)) and not (
                        any(x[1] in Combo for Combo in classCCombo))
                                  and not (any(x[0] in Combo for Combo in classBCombo)) and not (
                        any(x[1] in Combo for Combo in classBCombo))
                                  and not (any(x[0] in Combo for Combo in classACombo)) and not (
                        any(x[1] in Combo for Combo in classACombo))]

                    classDPair = [x for x in classDPair if not (any(x[0] in Combo for Combo in classDCombo)) and not (
                        any(x[1] in Combo for Combo in classDCombo))
                                  and not (any(x[0] in Combo for Combo in classCCombo)) and not (
                        any(x[1] in Combo for Combo in classCCombo))
                                  and not (any(x[0] in Combo for Combo in classBCombo)) and not (
                        any(x[1] in Combo for Combo in classBCombo))
                                  and not (any(x[0] in Combo for Combo in classACombo)) and not (
                        any(x[1] in Combo for Combo in classACombo))]

                    classASingle = [x for x in classASingle if not (any(x[0] in Pair for Pair in classDPair)) and not (
                        any(x[0] in Combo for Combo in classDCombo))
                                    and not (any(x[0] in Pair for Pair in classCPair)) and not (
                        any(x[0] in Combo for Combo in classCCombo))
                                    and not (any(x[0] in Pair for Pair in classBPair)) and not (
                        any(x[0] in Combo for Combo in classBCombo))
                                    and not (any(x[0] in Pair for Pair in classAPair)) and not (
                        any(x[0] in Combo for Combo in classACombo))]

                    classBSingle = [x for x in classBSingle if not (any(x[0] in Pair for Pair in classDPair)) and not (
                        any(x[0] in Combo for Combo in classDCombo))
                                    and not (any(x[0] in Pair for Pair in classCPair)) and not (
                        any(x[0] in Combo for Combo in classCCombo))
                                    and not (any(x[0] in Pair for Pair in classBPair)) and not (
                        any(x[0] in Combo for Combo in classBCombo))
                                    and not (any(x[0] in Pair for Pair in classAPair)) and not (
                        any(x[0] in Combo for Combo in classACombo))]

                    classCSingle = [x for x in classCSingle if not (any(x[0] in Pair for Pair in classDPair)) and not (
                        any(x[0] in Combo for Combo in classDCombo))
                                    and not (any(x[0] in Pair for Pair in classCPair)) and not (
                        any(x[0] in Combo for Combo in classCCombo))
                                    and not (any(x[0] in Pair for Pair in classBPair)) and not (
                        any(x[0] in Combo for Combo in classBCombo))
                                    and not (any(x[0] in Pair for Pair in classAPair)) and not (
                        any(x[0] in Combo for Combo in classACombo))]

                    classDSingle = [x for x in classDSingle if not (any(x[0] in Pair for Pair in classDPair)) and not (
                        any(x[0] in Combo for Combo in classDCombo))
                                    and not (any(x[0] in Pair for Pair in classCPair)) and not (
                        any(x[0] in Combo for Combo in classCCombo))
                                    and not (any(x[0] in Pair for Pair in classBPair)) and not (
                        any(x[0] in Combo for Combo in classBCombo))
                                    and not (any(x[0] in Pair for Pair in classAPair)) and not (
                        any(x[0] in Combo for Combo in classACombo))]

                    filterClassA = classACombo + classAPair + classASingle
                    filterClassB = classBCombo + classBPair + classBSingle
                    filterClassC = classCCombo + classCPair + classCSingle
                    filterClassD = classDCombo + classDPair + classDSingle
                else:
                    filterClassA = classACombo + classAPair + classASingle
                    filterClassB = classBCombo + classBPair + classBSingle
                    filterClassC = classCCombo + classCPair + classCSingle
                    filterClassD = classDCombo + classDPair + classDSingle

            classA = self.splitTrisToSingleAndPair(filterClassA)
            classB = self.splitTrisToSingleAndPair(filterClassB)
            classC = self.splitTrisToSingleAndPair(filterClassC)
            classD = self.splitTrisToSingleAndPair(filterClassD)

            return self.moveSelection(hand, field, turn, pass_turn, classA, classB, classC, classD, enemy1, enemy2,
                                      enemy3,
                                      control,
                                      cardClass, moveLists)

        # card1 = hand
        # card2 = field
        def higherSingle(self, card1, card2):
            return (self.card.getCardValues(card1)[0] - self.card.getCardValues(card2)[0]) > 0

        def higherPair(self, cards1, cards2):
            return (self.card.getPairScore(cards1) - self.card.getPairScore(cards2)) > 0

        def higherCombo(self, cards1, cards2):
            return (self.card.getComboScore(cards1) - self.card.getComboScore(cards2)) > 0

        def legalCard(self, cards):
            return (self.card.isSingle(cards) or self.card.isPair(cards) or self.card.isCombo(cards))

        def legalFirstMove(self, cards):
            if (self.legalCard(cards)):
                hand = self.card.sortingCards(cards)
                return hand[0] == '3D'
            return False

        def legalMove(self, cards, field):
            if (self.legalCard(cards) and self.legalCard(field)):
                if (self.card.isSingle(cards) and self.card.isSingle(field)):
                    return self.higherSingle(cards, field)
                if (self.card.isPair(cards) and self.card.isPair(field)):
                    return self.higherPair(cards, field)
                if (self.card.isCombo(cards) and self.card.isCombo(field)):
                    return self.higherCombo(cards, field)

        def possibleMoves(self, hand, field, control, turn):
            moveLists = []
            if control == True:

                [moveLists.append([x]) for x in hand]

                pairLists = self.card.getPair(hand)
                if pairLists:
                    [moveLists.append(x) for x in pairLists]

                comboLists = self.card.getCombo(hand)
                if comboLists:
                    [moveLists.append(x) for x in comboLists]
                if turn == 0:
                    moveLists = [x for x in moveLists if '3D' in x]
                return moveLists

            if len(field) == 1:
                for _ in hand:
                    single = [_]
                    if self.higherSingle(single, field):
                        moveLists.append(single)

            if len(field) == 2:
                pairLists = self.card.getPair(hand)
                if pairLists:
                    if len(pairLists) > 0:
                        for _ in pairLists:
                            if self.higherPair(_, field):
                                moveLists.append(_)

            if len(field) == 5:
                comboLists = self.card.getCombo(hand)
                if comboLists:
                    if len(comboLists) > 0:
                        for _ in comboLists:
                            if self.higherCombo(_, field):
                                moveLists.append(_)

            moveLists.append([])
            return moveLists


    def findPasses(self, currentGameHistory: GameHistory, numPlayers: int):
        # Check if it is not the first round of the game
        prev_pass_turn = {player: 0 for player in range(numPlayers - 1)}

        if len(currentGameHistory.gameHistory) > 1:
            # Access the previous round
            previousRoundTricksList = currentGameHistory.gameHistory[-2]
            for trick in previousRoundTricksList:
                if not trick.cards:
                    # if the trick was a pass, set the player to pass
                    prev_pass_turn[trick.playerNum] = 1

        pass_turn = {player: 0 for player in range(numPlayers - 1)}
        currentRoundTricks = currentGameHistory.gameHistory[-1]
        for trick in currentRoundTricks:
            if not trick.cards:
                pass_turn[trick.playerNum] = 1

        return pass_turn, prev_pass_turn

    # Determine which player won the last round
    def findRoundWinner(self, prev_pass_turn):
        winner = None
        # Should only be 1 player with score 0
        for player, hasPassed in prev_pass_turn.items():
            if hasPassed == 1:
                winner = player
        return winner

    def isInControl(self, prev_pass_turn, agentNum: int, currentGameHistory: List):
        if len(currentGameHistory) > 1:
            prevRoundWinner = self.findRoundWinner(prev_pass_turn)
            if prevRoundWinner != agentNum:
                return False
        return True > 1

    def getAction(self, state: MatchState):
        action = []  # The cards you are playing for this trick
        myData = state.myData  # Communications from the previous iteration

        # TODO Write your algorithm logic here

        card = Algorithm.Card()
        logic = Algorithm.Logic(card)
        agent = Algorithm.RulesAgent(card, logic)

        myPlayerNum = state.myPlayerNum

        # Current GameHistory object
        currentGame = state.matchHistory[-1]

        # List of rounds
        currentGameHistory = state.matchHistory[-1].gameHistory

        # All cards that have been played in turns this round
        if len(currentGameHistory) > 0:
            allTricks = [[card for card in turn.cards] for turn in currentGameHistory[-1]] # removed -1
            field_history = [card for turn in allTricks for card in turn]
        else:
            field_history = []

        print(f"Field History: {field_history}")

        playersObjectList = state.players  # .points, .handSize
        numPlayers = len(playersObjectList)
        opp1, opp2, opp3 = [player.handSize for i, player in enumerate(playersObjectList) if i != myPlayerNum]

        # Pass turn is a dict to store how many passes in the current round
        # If a player has passed, adjust their pass_turn score
        pass_turn, prev_pass_turn = self.findPasses(currentGame, numPlayers)

        # Deserialize the turn from myData
        try:
            # Convert the stored myData (which is a string) back into an integer representing the turn
            turn = int(myData) if myData else 0
        except ValueError:
            turn = 0  # If myData is somehow corrupted or empty, initialize turn to 0

        # Determine if the agent has won the last round using the findRoundWinner function
        isInControl = self.isInControl(prev_pass_turn, myPlayerNum, currentGameHistory)
        hand = state.myHand  # list of current cards

        # Field keeps track of the most recently played combo of cards (trick)
        field = state.toBeat.cards  # Object of the current trick

        # print(f"Pass Turn: {pass_turn}")
        # print(f"Prev Turn: {prev_pass_turn}")

        # increment the turn value for each player that has played this round
        # Logic to update the turn number based on pass comparison:
        for player in range(numPlayers - 1):  # Assuming 4 players (player 0 to player 3)
            # If the player passed in the current turn but didn't pass previously
            if prev_pass_turn[player] == 0 and pass_turn[player] == 1:
                turn += 1  # Increment the turn since the player just passed
            # If the player didn't pass (i.e., they made a valid move)
            elif pass_turn[player] == 0:
                turn += 1  # Increment the turn for a valid move

        # print(
        #     f"hand: {hand}, field: {field}, control: {isInControl}, turn: {turn}, field_history: {field_history}, enemy1, enemy2, enemy3, pass_turn ")

        best_move = agent.predictedMove(hand, field, isInControl, turn, field_history, opp1, opp2, opp3, pass_turn)
        action.append(best_move)

        # print(f"Best move: {best_move}")

        myData = str(turn)
        return action, myData

# # #
# # Instantiate some fake tricks
# trick1 = Trick(playerNum=0, cards=['3D', '5D', '9D'])
# trick2 = Trick(playerNum=1, cards=['6H', '7H', '8H'])
# trick3 = Trick(playerNum=2, cards=['4S', '5S', '6S'])
# trick4 = Trick(playerNum=3, cards=['2S', 'AD', 'KD'])
# pass_trick = Trick(playerNum=1, cards=[])  # Example of a passed trick (empty cards)
#
# # Create game history for the current game
# current_round = [trick1, trick2, trick3, trick4, pass_trick]  # This round has four tricks and one pass
#
# # History of the previous rounds (assuming two rounds have already been played)
# previous_round1 = [trick1, pass_trick, trick2]
# previous_round2 = [trick3, trick4, pass_trick]
#
# # Create GameHistory objects (one for a finished game, one for the current game)
# previous_game = GameHistory(finished=True, winnerPlayerNum=2, gameHistory=[previous_round1, previous_round2])
# current_game = GameHistory(finished=False, winnerPlayerNum=-1, gameHistory=[current_round])
#
# # Create a list of Player objects with fake points and hand sizes
# player0 = Player(points=10, handSize=5)
# player1 = Player(points=12, handSize=4)
# player2 = Player(points=15, handSize=3)
# player3 = Player(points=8, handSize=6)
#
# # List of players
# players = [player0, player1, player2, player3]
#
# # Cards in your hand (fake hand for the current player)
# my_hand = ['4D', '4C', '6D', '8H', '5D', 'AD', 'TD']
#
# # Trick to beat (this is the current trick on the table that you need to beat)
# to_beat = Trick(playerNum=2, cards=['4S', '5S', '6S'])  # Example trick from player 2
#
# # Fake data passed between iterations (starting as "0" for the first turn)
# my_data = "0"
#
# # Create the MatchState object
# match_state = MatchState(
#     myPlayerNum=0,  # Assume you are player 0
#     players=players,
#     myHand=my_hand,
#     toBeat=to_beat,
#     matchHistory=[previous_game, current_game],  # Including the previous game and the current ongoing game
#     myData=my_data
# )
#
# algo = Algorithm()
#
# algo.getAction(match_state)