import defs
Tiles = defs.Tiles
def addTuple(tu1, tu2):
    return map(lambda x: x[0] + x[1], zip( tu1, tu2 )) # addTuple((a1, a2), (b1, b2)) == (a1+b1, b2+b2)

def subTuple(tu1, tu2):
    return map(lambda x: x[0] - x[1], zip( tu1, tu2 )) # subTuple((a1, a2), (b1, b2)) == (a1-b1, b2-b2)

def findNeighbor(board, tile, row, col):
# vert i hor to tablice zawierające informacje o tym, gdzie można szukać sąsiada tak, żeby nie wykroczyć poza tablicę.
# vert w pionie, hor w poziomie
# np. vert == [-1, 0] oznacza że można szukać w tym samym rzędzie pionowym (0) albo o jeden rząd niżej (-1).
    vert = []
    if row != 0:
        vert.append(-1)
    vert.append(0)
    if row != len(board)-1:
        vert.append(1)

    hor = []
    if col != 0:
        hor.append(-1)
    hor.append(0)
    if row != len(board)-1:
        hor.append(1)

    i = 0
    for x in vert:
        ii = 0
        for y in hor:
            if board[row+i][col+ii] == tile:
                return row+i, col+ii
            ii += 1
        i += 1
    return False

def checkLine(board, row, col, tile, neighbor, counter, towin):
    offset = subTuple(neighbor, (row, col))
    if counter == towin:
        return tile
    #jeżeli następne sprawdzane pole byłoby poza tablicą, to znaczy, że dotarliśmy do końca planszy i można zakończyć szukanie
    elif row+offset[0] > len(board)-1 or col+offset[1] > len(board)-1:
        return False
    elif board[row+offset[0]][col+offset[1]] == tile:
        counter += 1
        return checkLine(board, neighbor[0], neighbor[1], tile, addTuple(neighbor, offset), counter, towin)
    else:
        return False

def checkBoard(board, players, towin):
    i = 0
    for row in board:
        col = 0
        for tile in row:
            neighbor = False
            if tile != Tiles.EMPTY:
                neighbor = findNeighbor(board, tile, i, col)
            if neighbor:
                return checkLine(board, i, col, tile, neighbor, 1, towin)
            col += 1
        i += 1