player_hands = []

def run(sorted_new_card):
    length = 1
    for k in range(len(sorted_new_card)-1):
        if (sorted_new_card[k][0] + 1 == sorted_new_card[k+1][0]
        and sorted_new_card[k][1] != sorted_new_card[k+1][1]):
            length += 1
        else:
            break
    if length >= 3:
       return True
    return False

def factorial(num):
    if num == 1:
        return num
    else:
        return num * factorial(num-1)

def test(cards):
    d_cards = {'2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8 , '9': 9,
               '0': 10, 'J': 11, 'Q': 12, 'K': 13, 'A': 20}
    ace_suit = []
    no_of_ace = 0
    score = 0
    new_card = []
    for i in cards:
        if i[0] == 'A':
            no_of_ace += 1
            if i[1] == 'D' or i[1] == 'H':
                ace_suit.append('r')
            else:
                ace_suit.append('b')
        elif i[1] == 'D' or i[1] == 'H':
            new_card.append((d_cards[i[0]],'r'))
        else:
            new_card.append((d_cards[i[0]],'b'))
    sorted_new_card = sorted(new_card)
    for i in sorted_new_card:
        score += i[0]
    if no_of_ace == 0:
        if run(sorted_new_card) is True:
            return score
        else:
            return -score
    else:
        if len(sorted_new_card) < 2:
            return - score - (20 * no_of_ace)
        min_value = sorted_new_card[0][0]
        max_value = sorted_new_card[-1][0]
        max_score = -999999999999999999999999999999999999999999999999
        if (max_value - min_value) < 2:
            return - score - (20*no_of_ace)
        if no_of_ace == 1:
            for i in range(min_value+1,max_value):
                sorted_new_card = sorted(new_card + [(i, ace_suit[0])])
                if run(sorted_new_card) is True:
                    score1 = score + i
                else:
                    score1 = -score - 20
                max_score = max(max_score,score1)
        elif no_of_ace == 2:
            for i in range(min_value+1,max_value):
                for j in range(min_value+1,max_value):
                    sorted_new_card = sorted(new_card + [(i, ace_suit[0])]+
                                         [(j, ace_suit[1])])
                    if run(sorted_new_card) is True:
                        score2 = score + i + j
                    else:
                        score2 = -score - 20 - 20
                    max_score = max(max_score,score2)
        elif no_of_ace == 3:
            for i in range(min_value+1,max_value):
                for j in range(min_value+1,max_value):
                    for k in range(min_value+1,max_value):
                        sorted_new_card = sorted(new_card + [(i, ace_suit[0])]+
                                         [(j, ace_suit[1])] + [(k,ace_suit[2])])
                        if run(sorted_new_card) is True:
                            score3 = score + i + j + k
                        else:
                            score3 = -score - 20 - 20 - 20
                        max_score = max(max_score,score3)
        elif no_of_ace == 4:
            for i in range(min_value+1,max_value):
                for j in range(min_value+1,max_value):
                    for k in range(min_value+1,max_value):
                        for z in range(min_value+1,max_value):
                            sorted_new_card = sorted(new_card
                                                     + [(i, ace_suit[0])]
                                         +[(j, ace_suit[1])] + [(k,ace_suit[2])]
                                         + [(z, ace_suit[3])])
                            if run(sorted_new_card) is True:
                                score4 = score + i + j + k + z
                            else:
                                score4 = -score - 20 - 20 - 20 - 20
                            max_score = max(max_score,score4)
        return max_score

def score_group(cards):
    d_cards = {'2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8 , '9': 9,
               '0': 10, 'J': 11, 'Q': 12, 'K': 13, 'A': 20}
    card = cards[0][0]
    score1 = test(cards)
    n_of_a_kind = False
    number = 0
    for value in cards:
        if value[0] == card:
            number += 1
    if number == len(cards) and len(cards) >= 2 and card != 'A':
        n_of_a_kind = True
        score2 = d_cards[card] * factorial(number)

    if n_of_a_kind is False:
        return score1
    else:
        return max(score1, score2)

# question 2 code
def is_valid(groups):
    if groups == []:
        return True
    if len(groups) > 10:
        return False

    for i in groups:
        if len(i) == 1:
            continue

        number = 0
        for value in i:
            if value[0] == i[0][0]:
                number += 1
        if number == len(i) and len(i) >= 2 and i[0][0] != 'A':
            continue

        if test(i) is True:
            continue
        return False
    return True

def comp10001go_play(discard_history, player_no, hand):
    ''' Takes a list of lists containing discard pile, the player number and
    the current hand to choose a card to add to the discard pile.'''
    d_cards = {'2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8 , '9': 9,
               '0': 10, 'J': 11, 'Q': 12, 'K': 13, 'A': 20}

    possible_cards = {'2': 0, '3': 0, '4': 0, '5': 0, '6': 0, '7': 0, '8': 0 ,
                  '9': 0, '0': 0, 'J': 0, 'Q': 0, 'K': 0, 'A': 0}

    taken_cards = {'2': 0, '3': 0, '4': 0, '5': 0, '6': 0, '7': 0, '8': 0 ,
                  '9': 0, '0': 0, 'J': 0, 'Q': 0, 'K': 0, 'A': 0}

    my_cards = {'2': 0, '3': 0, '4': 0, '5': 0, '6': 0, '7': 0, '8': 0 ,
                  '9': 0, '0': 0, 'J': 0, 'Q': 0, 'K': 0, 'A': 0}

    my_cards_suit ={'2': {'r': 0, 'b': 0},
                    '3': {'r': 0, 'b': 0},
                   '4': {'r': 0, 'b': 0},
                   '5': {'r': 0, 'b': 0},
                   '6': {'r': 0, 'b': 0},
                   '7': {'r': 0, 'b': 0},
                   '8': {'r': 0, 'b': 0},
                  '9': {'r': 0, 'b': 0},
                  '0': {'r': 0, 'b': 0},
                  'J': {'r': 0, 'b': 0},
                  'Q': {'r': 0, 'b': 0},
                  'K': {'r': 0, 'b': 0},
                  'A': {'r': 0, 'b': 0}}

    if len(player_hands) != 4:
        player_hands.append([hand])
    else:
        for discarded in discard_history:
            i=0
            for card in [player_no,(player_no+1)%4,(player_no+2)%4,(player_no+3)%4]:
                try:
                    player_hands[i].remove(discarded[card])
                    i += 1
                except:
                    i += 1
                    pass

    new_hand = []
    for card in hand:
        if card[1] in 'DH':
            new_hand.append((card[0], 'r'))
        else:
            new_hand.append((card[0], 'b'))

    for card in hand:
        possible_cards[card[0]] += 1

    for discarded in discard_history:
        for card in range(len(discarded)):
            if card == player_no:
                my_cards[discarded[card][0]] += 1
                if discarded[card][1] in 'DH':
                    my_cards_suit[discarded[card][0]]['r'] += 1
                else:
                    my_cards_suit[discarded[card][0]]['b'] += 1
            else:
                taken_cards[discarded[card][0]] += 1

    for card in hand:
        if d_cards[card[0]] in [10,9,8,7]:
            if possible_cards[card[0]] == 1 or possible_cards[card[0]] == 4:
                if taken_cards[card[0]] == 0:
                    return card

    for test in [10,9,8]:
        for card in hand:
            if d_cards[card[0]] == test:
                if possible_cards[card[0]] == 1 or possible_cards[card[0]] == 4:
                    if taken_cards[card[0]] == 0:
                        return card

    for test in ['J','Q','K']:
        for card in hand:
            if card[0] == test:
                return card

    my_card = [d_cards[card] for card in my_cards.keys() if my_cards[card]==1]
    min_value = min(my_card)
    max_value = max(my_card)
    difference = max_value - min_value

    for discarded in discard_history:
        if d_cards[discarded[player_no][0]] == min_value:
            min_value = (min_value, discarded[player_no][1])
        if d_cards[discarded[player_no][0]] == max_value:
            max_value = (max_value, discarded[player_no][1])

    if min_value[1] in 'DH':
        min_suit = 'r'
    else:
        min_suit = 'b'
    if max_value[1] in 'DH':
        max_suit = 'r'
    else:
        max_suit = 'b'

    for card in hand:
        test_suit = card[1]
        if test_suit in 'DH':
            test_suit = 'r'
        else:
            test_suit = 'b'
        if (card[0] in range(min_value[0]+1,max_value[0]) and test_suit != min_suit
        and test_suit != max_suit):
            return card

    for test in [7,6,5,4,3,2]:
        for card in hand:
            if d_cards[card[0]] == test:
                if possible_cards[card[0]] == 1 or possible_cards[card[0]] == 4:
                    if taken_cards[card[0]] == 0:
                        return card

    return hand[0]

def comp10001go_group(discard_history, player_no):
    ''' '''
    possible_cards = {'2': 0, '3': 0, '4': 0, '5': 0, '6': 0, '7': 0, '8': 0 ,
                  '9': 0, '0': 0, 'J': 0, 'Q': 0, 'K': 0, 'A': 0}
    d_cards = {'2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8 , '9': 9,
               '0': 10, 'J': 11, 'Q': 12, 'K': 13, 'A': 20}
    my_cards = []
    n_of_a_kind = []
    run = []
    best_group = []

    for discarded in discard_history:
        my_cards.append(discarded[player_no])

    my_cards_c1 = my_cards.copy()

    for card in my_cards:
        possible_cards[card[0]] += 1

    for (k, v) in possible_cards.items():
        if v > 1:
            for card in my_cards_c1:
                n_of_a_kind.append(card)
                my_cards_c1.remove(card)
    if(n_of_a_kind!=[]):
        best_group.append(n_of_a_kind)

    actual_run=[]
    new_cards_c1 = []

    for i in my_cards_c1:
        if i[1] == 'D' or i[1] == 'H':
            new_cards_c1.append((d_cards[i[0]],'r'))
        else:
            new_cards_c1.append((d_cards[i[0]],'b'))

    new_cards_c1 = sorted(new_cards_c1)
    lost_points = 0
    for j in range(len(new_cards_c1)):
        still_can_add = True
        length = 1
        score = new_cards_c1[j][0] - lost_points
        run = []
        run.append(new_cards_c1[j])
        lost_points += new_cards_c1[j][0]
        for k in range(j,len(my_cards_c1)-1):
            if (new_cards_c1[k][0] + 1 == new_cards_c1[k+1][0]
            and new_cards_c1[k][1] != new_cards_c1[k+1][1]
            and still_can_add is True):
                length += 1
                score += new_cards_c1[k+1][0]
                run.append(new_cards_c1[k+1])
            else:
                still_can_add = False
                score -= new_cards_c1[k+1][0]

        if length >= 3:
           actual_run = run.copy()
           leftover_score = score

    leftover_score = -lost_points

    if(actual_run!=[]):
        final_run=[]
        for i in actual_run:
            for j in my_cards:
                if(i[0]==j[0]):
                    if i[1] == 'r' and j[1] in 'DH':
                        final_run.append(j)
                    elif i[1] == 'b' and j[1] in 'SC':
                        final_run.append(j)
        best_group.append(final_run)

    for card in my_cards_c1:
        if(n_of_a_kind!=[]):
            if card in n_of_a_kind:
                continue
        if actual_run != []:
            if card in actual_run:
                continue
        best_group.append([card])

    return best_group