import config

import os

import uuid

import random

class Player:

    def __init__(self, game, name):

        self.game = game

        self.name = name

        self.id = str(uuid.uuid4())

        self.joined = False

        self.word = ""

        self.wordused = False

        self.ready = False

        self.selection = -1

        self.shuffle = []

        self.shuffleinv = []

        players[self.id] = self

    def beginturn(self):

        self.wordused = self.word and self.word == self.game.word

        self.ready = False

        self.selection = -1

        self.shuffle = list(range( len(self.game.cards) - 1)) # do not shuffle the last card (the skip turn card)

        random.shuffle(self.shuffle)

        self.shuffleinv = list(range(len(self.shuffle)))

        for i in range(len(self.shuffle)):

            self.shuffleinv[self.shuffle[i]] = i;

    def realindex(self, index):

        return self.shuffle[index] if index >= 0 and index < len(self.shuffle) else index

    def virtualindex(self, index):

        return self.shuffleinv[index] if index >= 0 and index < len(self.shuffleinv) else index

    def realselection(self):

        return self.realindex(self.selection)

    def join(self, word):

        if not self.joined:

            del players[self.id]

            self.id = str(uuid.uuid4())

            players[self.id] = self

            self.word = " ".join(str(word).split()) # replace all whitespace character sequences to single space

            self.joined = True

            self.game.playerJoin()

    def select(self, i):

        if self.selection < 0 and i >= 0 and i < len(self.game.cards):

            self.selection = i

            self.game.playerSelect()

    def nextturn(self, word):

        if self.game.selected and not self.ready:

            self.word = str(word).strip()

            self.ready = True

            self.game.playerReady()

    def status(self):

        friend = self.game.players[1] if self.game.players[0] == self else self.game.players[0]

        friendId = None if friend.joined else friend.id

        friendSelection = self.virtualindex( friend.realselection() if self.game.selected else -1 )

        percent = None

        turns = self.game.turn - self.game.skips

        if not self.game.selected: turns -= 1

        if turns:

            percent = round(self.game.score/turns*100, 2)

        cards = []

        for i in range(0, len(self.game.cards)):

            cards.append({ "index": i, "name": self.game.cards[self.realindex(i)], "my": self.selection == i, "friends": friendSelection == i })

        return {

            "vocabulary": self.game.vocabulary,

            "turn": self.game.turn,

            "skips": self.game.skips,

            "score": self.game.score,

            "turns": turns,

            "percent": percent,

            "word": self.game.word,

            "wordSource": self.game.wordSource,

            "cards": cards,

            "started": self.game.started,

            "selected": self.game.selected,

            "host": config.externalHost,

            "prefix": config.prefix,

            "cardsPrefix": config.cardsPrefix,

            "waiting": (self.joined and not self.game.started) or (self.selection >= 0 and not self.game.selected) or self.ready,

            "lose": self.game.turnResult == 1,

            "win": self.game.turnResult == 2,

            "skipped": self.game.turnResult == 3,

            "me": {

                "id": self.id,

                "name": self.name,

                "word": self.word,

                "wordused": self.wordused,

                "selection": self.selection,

                "selected": self.selection >= 0,

                "ready": self.ready },

            "friend": {

                "id": friendId,

                "selection": friendSelection } }

class Game:

    def __init__(self, vocabulary, word):

        self.vocabulary = vocabulary

        self.words = words.get(vocabulary, ["no words for choose, sorry..."])

        self.players = ( Player(self, "Player1"), Player(self, "Player2") )

        self.turn = 1

        self.score = 0

        self.skips = 0

        self.started = False

        self.selected = False

        self.turnResult = 0

        self.cards = []

        self.word = ""

        self.wordSource = ""

        self.players[0].join(word)

    def beginturn(self):

        assert(cards)

        self.cards.clear()

        for i in range(0, config.cardsCount):

            for j in range(0, 100):

                card = cards[ random.randrange(0, len(cards)) ]

                if not card in self.cards:

                    self.cards.append(card)

                    break

        self.cards.append(skipname)

        w0 = self.players[0].word

        w1 = self.players[1].word

        w0u = self.players[0].wordused

        w1u = self.players[1].wordused

        if not w0 and not w1:

            self.word = random.choice(self.words)

            self.wordSource = "choosen by random"

        elif not w1:

            self.word = w0

            self.wordSource = "suggested by player1"

        elif not w0:

            self.word = w1

            self.wordSource = "suggested by player2"

        elif w0 == w1:

            self.word = w0

            self.wordSource = "suggested by both players"

        elif w0u < w1u or (w0u == w1u and random.randrange(2)):

            self.word = w0

            self.wordSource = "suggested by player1 (player2 may be lucky next time)"

        else:

            self.word = w1

            self.wordSource = "suggested by player2 (player1 may be lucky next time)"

        self.turnResult = 0

        self.selected = False

        for p in self.players:

            p.beginturn()

    def playerJoin(self):

        if not self.started and all(p.joined for p in self.players):

            self.started = True

            self.beginturn()

    def playerSelect(self):

        if self.started and not self.selected and all(p.selection >= 0 for p in self.players):

            self.selected = True

            self.turnResult = 1

            if any(p.realselection() == len(self.cards) - 1 for p in self.players):

                self.skips += 1

                self.turnResult = 3

            elif self.players[0].realselection() == self.players[1].realselection():

                self.score += 1

                self.turnResult = 2

            else:

                self.turnResult = 1

            if self.turnResult != 3:

                for p in self.players:

                    if p.word == self.word:

                        p.word = ""

    def playerReady(self):

        if self.started and self.selected and all(p.ready for p in self.players):

            self.turn = self.turn + 1

            self.beginturn()

def mergeCards(path):

    for f in os.scandir(path):

        if f.is_file() and f.name.endswith(".jpg") and f.name != skipname:

            cards.append(f.name)

def mergeWords(path):

    for f in os.scandir(path):

        if f.is_file() and f.name.endswith(".txt"):

            n = f.name[:-4]

            ws = set(words.get(n, []))

            with open(path + "/" + f.name, "r") as ff:

                for word in ff.readlines():

                    w = word.strip()

                    if w != "":

                        ws.add(w)

            if ws:

                if not n in words:

                    words[n] = []

                words[n].clear()

                words[n] += ws

skipname = "skip.jpg"

players = {}

cards = []

words = {}