import random

class GameBoard():
    def __init__(self, size):
        self.size = size
        self.gameboard = []
        for _ in range(self.size):
            self.gameboard.append([0 for _ in range(self.size)])

    # hopefully this is a tuple
    # ret true on succ, false on fuck
    def setVal(self, pos, val):
        if pos[0] < 0 or pos[1] < 0 or pos[0] > self.size or pos[1] > self.size:
            raise Exception("Out of bounds")
        self.gameboard[pos[0]][pos[1]] = val
        return True

    def getVal(self, pos):
        return self.gameboard[pos[0]][pos[1]]

    def mergeable(self, p1, p2):
        v1 = self.getVal(p1)
        v2 = self.getVal(p2)
        return v1 == v2

    def merge(self, p1, p2):
        if self.mergeable(p1, p2):
            v = self.getVal(p1)
            self.setVal(p1, v*2)
            self.setVal(p2, 0)

    def count(self, n):
        # returns num of occurrances
        t = 0
        for r in self.gameboard:
            for e in r:
                if e == n:
                    t += 1
        return t

    # populate with n random elements
    # there's a better way to distribute this, but I'm not figuring it out now.
    def populate(self, n):
        def getPos():
            x = random.randint(0, self.size - 1)
            y = random.randint(0, self.size - 1)
            return (x,y)
        for _ in range(n):
            p = getPos()
            v = 2 ** random.randint(0, self.size)
            while self.getVal(p) != 0:
                p = getPos()
            self.setVal(p, v)

    # moves a column to where all elements are next to each other at either the bottom or top
    def shiftCol(self, c, d):
        def swap(p1, p2):
            pass
        if c < 0 or c > self.size:
            raise Exception("Out of bounds")
        col = list(filter( lambda x: x > 0, [r[c] for r in self.gameboard]))
        if d == "u":
            # I believe itll be col + [0]*diff back into the col place of the game board
            for i in range(self.size):
                if i < len(col):
                    self.gameboard[i][c] = col[i]
                else:
                    self.gameboard[i][c] = 0
        elif d == "d":
            diff = self.size - len(col)
            for i in range(self.size):
                if i < diff:
                    self.gameboard[i][c] = 0
                else:
                    self.gameboard[i][c] = col[i - diff]
        else:
            raise Exception("Invalid direction")

        def shift_and_merge(p1, p2):
            if self.mergeable(p1, p2):
                self.merge(p1,p2)
            else:
                if self.getVal(p1) == 0 and self.getVal(p2) != 0:
                    swap(p1,p2)

        col = [r[c] for r in self.gameboard]
        if d == "u":
            for x in range(len(col)-1):
                p1 = (x,c)
                p2 = (x+1,c)
                shift_and_merge(p1,p2)
        elif d == "d":
            for x in range(len(col)-1, 0, -1):
                p1 = (x,c)
                p2 = (x-1,c)
                shift_and_merge(p1,p2)

    def shiftRow(self, r, d):
        def swap(p1, p2):
            v1 = self.getVal(p1)
            v2 = self.getVal(p2)
            self.setVal(p1, v2)
            self.setVal(p2, v1)
        if r < 0 or r > self.size:
            raise Exception("Out of bounds")
        row = list(filter(lambda x: x != 0 , self.gameboard[r]))
        diff = self.size - len(row)
        if d == "l":
            row = row + [0] * diff
        elif d == "r":
            row = [0] * diff + row
        else:
            raise Exception("Invalid direction")
        self.gameboard[r] = row
        def shift_and_merge(p1, p2):
            #shift and merge into p1
            if self.mergeable(p1, p2):
                self.merge(p1,p2)
            else:
                if self.getVal(p1) == 0 and self.getVal(p2) != 0:
                    swap(p1,p2)
        if d == "l":
            for x in range(len(row)-1):
                p1 = (r,x)
                p2 = (r,x+1)
                shift_and_merge(p1,p2)
        elif d == "r":
            for x in range(len(row)-1, 0, -1):
                p1 = (r,x)
                p2 = (r,x-1)
                shift_and_merge(p1,p2)

    def shiftBoard(self, d):
        if d == "u" or d == "d":
            for i in range(self.size):
                self.shiftCol(i, d)
        elif d == "l" or d == "r":
            for i in range(self.size):
                self.shiftRow(i, d)
        else:
            raise Exception("Invalid direction")

    def printBoard(self):
        for r in self.gameboard:
            print("_" * 4 * self.size + "\n")
            print("| " + " | ".join([str(x) for x in r]) + " |")
        print("_" * 4 * self.size)

def main():
    running = True
    while running:
        s = input("How big of a board? (q to quit)>")
        if s == "q":
            running = False
        else:
            e = input("How many elements? (q to quit)>")
        if s != "q" and e != "q":
            b = GameBoard(int(s))
            b.populate(int(e))
            b.printBoard()
            opt = input("dir (q to reset)>")
            while opt != "q":
                if opt in list("udlr"):
                    b.shiftBoard(opt)
                b.printBoard()
                opt = input("dir (q to reset)>")
        else:
            running = False