import numpy as np
import sys
from random import randint
from PyQt4.QtGui import *
from PyQt4.QtCore import *

a = QApplication(sys.argv)
l = Qt.Key_Left
r = Qt.Key_Right
u = Qt.Key_Up
d = Qt.Key_Down
arrows = (l, u, r, d)


class Game():
    def __init__(self):
        self.resetgame()

    size = 4
    matrix = []

    def resetgame(self):
        self.matrix = np.zeros((self.size, self.size), dtype=np.int)
        self.add_element()
        self.add_element()

    def add_element(self):
        temp2 = randint(0, 9)
        x = randint(0, self.size - 1)
        y = randint(0, self.size - 1)
        if self.matrix[y, x] == 0:
            self.matrix[y, x] = 4 if temp2 == 0 else 2
        else:
            self.add_element()

    def move_elements(self, arr) -> np.matrix:
        for x in range(self.size):
            temp = 0
            for y in range(self.size):
                if not arr[y, x] == 0:
                    arr[temp, x] = arr[y, x]
                    if not temp == y:
                        arr[y, x] = 0
                    temp += 1
        return arr

g = Game()


class Window(QWidget):
    def __init__(self):
        super(Window, self).__init__()
        self.init_ui()
        self.set_values()
        self.setStyleSheet("QWidget {"
                           "background-color: #bbada0;}")

    bestscore = 0
    scoreval = 0
    score = None
    best = None
    grid = QGridLayout()
    table = []
    color = {0:     "#ccc0b3;",
             2:     "#eee4da;",
             4:     "#EDE0C8;",
             8:     "#F2B179;",
             16:    "#F59563;",
             32:    "#F67C5F;",
             64:    "#F65E3B;",
             128:   "#EDCE70;",
             256:   "#EDCC63;",
             512:   "#ECC850;",
             1024:  "#ECC850;",
             2048:  "#EDC22E;",
             1:     "#000;"}
    ct = {0:     "black;",
          2:     "black;",
          4:     "black;",
          8:     "white;",
          16:    "white;",
          32:    "white;",
          64:    "white;",
          128:   "white;",
          256:   "white;",
          512:   "white;",
          1024:  "white;",
          2048:  "white;"}

    def set_score(self):
        self.scoreval = 0
        for x in range(g.size):
            for y in range(g.size):
                if g.matrix[y, x] > 2:
                    self.scoreval += g.matrix[y, x] * (np.log(g.matrix[y, x])/np.log(2) - 1)

    def reset(self):
        self.scoreval = 0
        g.resetgame()
        self.set_values()
        self.setFocus()

    def init_ui(self):
        self.resize(g.size*112.5, g.size*125)
        self.setMaximumSize(g.size*112.5, g.size*125)
        self.setMinimumSize(g.size*112.5, g.size*125)
        self.setWindowTitle("2048")
        self.show()
        self.setLayout(self.grid)

        self.best = QLabel("Best:\n%s" % self.bestscore)
        self.best.setFixedHeight(50)
        self.best.setFixedWidth(100)
        self.best.setAlignment(Qt.AlignCenter)
        self.best.setStyleSheet("QLabel {"
                                "color: #fff;"
                                "font-size: 15px;"
                                "border-radius: 5px;"
                                "background-color: #000;"
                                "font-family: Arial Black;"
                                "}")
        self.grid.addWidget(self.best, 0, 1, 1, g.size/2)

        self.score = QLabel("Score:\n0")
        self.score.setFixedHeight(50)
        self.score.setFixedWidth(100)
        self.score.setAlignment(Qt.AlignCenter)
        self.score.setStyleSheet("QLabel {"
                                 "color: #fff;"
                                 "font-size: 15px;"
                                 "border-radius: 5px;"
                                 "background-color: #000;"
                                 "font-family: Arial Black;"
                                 "}")
        self.grid.addWidget(self.score, 0, 0, 1, g.size/2)

        restart = QPushButton("Restart")
        restart.clicked.connect(self.reset)
        restart.setFixedWidth(g.size*50 + (g.size/2 - 1)*5)
        restart.setFixedHeight(50)
        restart.setStyleSheet("QPushButton {"
                              "color: #fff;"
                              "font-size: 15px;"
                              "border-radius: 5px;"
                              "background-color: #000;"
                              "font-family: Arial Black;"
                              "}")
        self.grid.addWidget(restart, 0, g.size/2, 1, g.size/2)

        label_temp = []
        k = 0
        for m in range(g.size):
            for n in range(g.size):
                if not k % g.size:
                    self.table.append(label_temp)
                    label_temp = []
                    k = 0
                label_temp.append(QLabel('0'))
                label_temp[k].setFixedWidth(100)
                label_temp[k].setAlignment(Qt.AlignCenter)
                self.grid.addWidget(label_temp[k], m + 1, n)
                k += 1
        self.table.append(label_temp)
        self.table.pop(0)

    def set_values(self):
        for m in range(g.size):
            for n in range(g.size):
                self.table[m][n].setText(str(g.matrix[m, n]) if g.matrix[m, n] > 0 else " ")
                try:
                    self.table[m][n].setStyleSheet("QLabel {"
                                                   "color: %s;"
                                                   "font-size: 35px;"
                                                   "border-radius: %spx;"
                                                   "font-family: Arial Black;"
                                                   "background-color: %s"
                                                   "}"
                                                   % (self.ct[g.matrix[m, n]], g.size*12.5, self.color[g.matrix[m, n]]))
                except KeyError:
                    self.table[m][n].setStyleSheet("QLabel {"
                                                   "color: white;"
                                                   "font-size: 35px;"
                                                   "border-radius: %spx;"
                                                   "font-family: Arial Black;"
                                                   "background-color: %s"
                                                   "}"
                                                   % (g.size*12.5, self.color[1]))

        self.set_score()
        self.score.setText("Score:\n%s" % int(self.scoreval))

        if self.bestscore < self.scoreval:
            self.bestscore = self.scoreval
            self.best.setText("Best:\n%s" % int(self.bestscore))

    def keyPressEvent(self, k):
        k = k.key()
        if not any(self.is_legal(x) for x in arrows) and g.matrix.all():
            msbx = QMessageBox()
            msbx.setText("You won!")
            msbx.setWindowTitle("End")
            msbx.setStandardButtons(QMessageBox.Ok)
            msbx.show()
            msbx.exec_()
        if any(k == x for x in arrows):
            self.sum(k)
        elif k == Qt.Key_A:
            ai_1()
        elif k == Qt.Key_R:
            self.reset()
        elif k == Qt.Key_T:
            test()

    def sum(self, k):
        if not self.is_legal(k):
            return
        arr = g.matrix
        arr = np.flipud(arr) if k == d else np.rot90(arr, -1) if k == l else np.rot90(arr, 1) if k == r else arr
        arr = g.move_elements(arr)
        for x in range(g.size):
            for y in range(g.size - 1):
                if arr[y, x] == arr[y + 1, x]:
                    arr[y, x] *= 2
                    arr[y + 1, x] = 0
                    arr = g.move_elements(arr)
        g.matrix = np.flipud(arr) if k == d else np.rot90(arr, 1) if k == l else np.rot90(arr, -1) if k == r else arr
        g.add_element()
        self.set_values()

    @staticmethod
    def is_legal(k) -> bool:
        arr = g.matrix
        arr = np.flipud(arr) if k == u else np.rot90(arr, -1) if k == r else np.rot90(arr, 1) if k == l else arr
        for x in range(g.size):
            for y in range(g.size - 1):
                if arr[y, x] and (arr[y + 1, x] == 0 or arr[y + 1, x] == arr[y, x]):
                    return True
        return False

w = Window()


def no_updown() -> int:
    count = 0
    arr = g.matrix
    arr = g.move_elements(arr)
    for x in range(g.size):
        for y in range(g.size - 1):
            if arr[y, x] == arr[y + 1, x] and arr[y, x] > 0:
                arr[y, x] *= 2
                arr[y + 1, x] = 0
                count += 1
    return count


def no_leftright() -> int:
    count = 0
    arr = g.matrix
    arr = np.rot90(arr, -1)
    arr = g.move_elements(arr)
    for x in range(g.size):
        for y in range(g.size - 1):
            if arr[y, x] == arr[y + 1, x] and arr[y, x] > 0:
                arr[y, x] *= 2
                arr[y + 1, x] = 0
                count += 1
    return count


def test():
    print(no_updown())
    print(no_leftright())


def ai_1():
    """
Counts where are more addings horizotnal/vertical. Chooses better move if can. Else prioritize up > left > down > right.

    """
    end = False
    while 1:
        if no_updown() > no_leftright():
            if w.is_legal(u):
                w.sum(u)
            elif w.is_legal(d):
                w.sum(d)
        elif no_leftright() > no_updown():
            if w.is_legal(l):
                w.sum(l)
            elif w.is_legal(r):
                w.sum(r)
        else:
            if w.is_legal(u):
                w.sum(u)
            elif w.is_legal(l):
                w.sum(l)
            elif w.is_legal(d):
                w.sum(d)
            elif w.is_legal(r):
                w.sum(r)
        if not any(w.is_legal(x) for x in arrows) and g.matrix.all():
            for e in g.matrix.flatten():
                if e > 511:
                    end = True
                else:
                    g.resetgame()
        if end:
            break


def ai_2():
    if not g.matrix[0, :].all():
        if w.is_legal(u):
            w.sum(u)
        elif w.is_legal(l):
            w.sum(l)
    elif g.matrix[0, :].all() and not g.matrix[1, :].all():
        if w.is_legal(u):
            w.sum(u)
        elif w.is_legal(r):
            w.sum(r)
        elif w.is_legal(l):
            w.sum(l)
    elif g.matrix[0, :].all() and g.matrix[1, :].all() and not g.matrix[2, :].all():
        if w.is_legal(u):
            w.sum(u)
        elif w.is_legal(l):
            w.sum(l)
        elif w.is_legal(r):
            w.sum(r)
    else:
        w.sum(d)
        w.sum(u)
        w.sum(r)
        w.sum(l)



w.setFocus()
sys.exit(a.exec())