import tensorflow as tf
from tensorflow import keras
import numpy as np

np.random.seed(0)

def gen_party(players_count):
    deck = [i for i in range(36)]
    np.random.shuffle(deck)

    known_cards = [0] * 36
    players_turns = [0] * players_count
    for i in range(players_count) : players_turns[i] = []

    table, beaten, offside, out = [], [], [], []


    players = [0] * players_count
    for i in range(players_count):
        players[i] = [0] * 6
        for c in range(6):
            players[i][c] = deck.pop()

    trump = deck.pop();
    deck.insert(0, trump)
    trump //= 9

    def is_higher(card1, card2):
        if card1 // 9 != card2 // 9 : return card1 // 9 == trump and (card2 // 9 != trump or card1 > card2)
        return card1 > card2


    def can_be_beaten(player_hand, player_table, result) :
        for idx, card in enumerate(player_hand):
            if is_higher(card, table[-1]):
                result.append(idx)
                if len(player_table) == 1 : return result
                hand_copy, table_copy = player_hand.copy(), player_table.copy()
                hand_copy.pop(idx)
                table_copy.pop()
                new_result = can_be_beaten(hand_copy, table_copy, result)
                if len(new_result) != 0 : return result
                result.pop()
        return []




    #0 - unknown, 1 - at hand, 2 - attacking, 3 - destroyed, 4 - other player, 5 - offside
    def fill_turn(player, result, attack):
        turn_info = [0] * 38
        for idx, k in enumerate(known_cards):
            if k != 0:
                turn_info[idx] = 4 #other palyer

        for i in offside: turn_info[i] = 5 #offside

        for i in players[player] : turn_info[i] = 1 #at hand

        for i in beaten : turn_info[i] = 3 #destroyed

        for i in table : turn_info[i] = 2 #attacking

        turn_info[36] = trump

        if (attack) : turn_info[37] = 1

        if result < 36 : out[result] = 0.9

        players_turns[player].append(turn_info + out)

    turn_pl = 0
    min = 36
    for idx, hand in enumerate(players):
        for card in hand:
            if card // 9 == trump and card < min:
                min = card
                turn_pl = idx

    def_pl = (turn_pl + 1) % players_count

    while True:
        np.random.shuffle(players[def_pl])
        np.random.shuffle(players[turn_pl])
        card = players[turn_pl].pop()
        out = [0.1] * 36;
        for c in players[turn_pl] : out[c] = 0.5
        fill_turn(turn_pl, card, True)
        table.append(card)
        while True:
            all = table + beaten
            for i in range(players_count):
                if i == def_pl : continue
                out = [0.1] * 36
                for c in players[i] : out[c] = 0.3
                if len(players[def_pl]) == len(table) : break;
                for table_card in all:
                    for idx, player_card in enumerate(players[i]):
                        if player_card % 9 == table_card % 9:
                            out[player_card] = 0.5
                            if np.random.randint(0, 4) == 0:
                                fill_turn(i, player_card, True)
                                table.append(player_card)
                                players[i].pop(idx)
                            else:
                                fill_turn(i, 36, True)

            if len(table) == 0 : break;
            table[::-1].sort()
            if table[0] == 28:
                c = 1
            variant = can_be_beaten(players[def_pl], table, [])
            out = [0.1] * 36
            for c in players[def_pl] : out[c] = 0.3
            for v in variant : out[v] = 0.5
            if len(variant) == 0 or np.random.randint(0, 6) == 0:
                fill_turn(def_pl, 36, False)
                all = table + beaten
                players[def_pl] += all
                for i in all : known_cards[i] = 1
                table, beaten = [], []
                break

            for idx in variant:
                fill_turn(def_pl, players[def_pl][idx], False)
                beaten.append(players[def_pl].pop(idx))
                beaten.append(table.pop())
            if len(players[def_pl]) == 0 : break

        for i in range(players_count):
            if len(deck) == 0 : break
            cpl = (i + turn_pl) % players_count
            if cpl == def_pl : continue
            for i in range(len(players[cpl]), 6) :
                if len(deck) == 0 : break
                if (len(deck) == 1) : known_cards[deck[0]] = 1
                players[cpl].append(deck.pop())

        for i in range(len(players[def_pl]), 6):
            if len(deck) == 0 : break
            if (len(deck) == 1) : known_cards[deck[0]] = 1
            players[def_pl].append(deck.pop())

        if len(deck) == 0:
            for i in range(players_count):
                if len(players[i]) == 0 : return players_turns[i]

        if len(beaten) == 0 : turn_pl = (def_pl + 1) % players_count
        else:
            turn_pl = def_pl;
            offside += beaten
            beaten = []

        def_pl = (turn_pl + 1) % players_count

def expand_turn(turn):
    result = [0] * 2
    result[0] = [0.1] * 221
    result[1] = turn[38:]
    for i in range(36):
        result[0][i * 6 + turn[i]] = 0.9
    result[0][216 + turn[36]] = 0.9
    if turn[37] != 0 : result[0][220] = 0.9
    return result

model = keras.Sequential([
    keras.layers.Dense(300, input_shape=(221,)),
    keras.layers.Dense(150, activation=tf.nn.sigmoid),
    keras.layers.Dense(36, activation=tf.nn.sigmoid)
    ])

model.compile(optimizer=tf.train.AdamOptimizer(), loss='categorical_crossentropy', metrics=['accuracy'])

inputs = np.empty((1,221))
outputs = np.empty((1, 36))
for i in range(100):
    party = gen_party(3)
    for turn in party :
        res = expand_turn(turn)
        inputs = np.vstack((inputs, res[0]))
        outputs = np.vstack((outputs, res[1]))

model.fit(inputs, outputs, epochs=1000)