func _ready() -> void:
    GlobalNodes.baseGridNode = self

    var cellDimensions : Vector2 = Vector2(125,125)

    # Instantiate and place grid cells into the game world
    for y in range(gridRowsCount):
        var tempRow : Array[Node2D]
        for x in range(gridColumnsCount):
            var tempSquare : GridCell = gridSquare.instantiate()
            tempSquare.position = position + Vector2(cellDimensions.x * x, cellDimensions.y * y)
            tempSquare.gridRow = y
            tempSquare.gridColumn = x
            tempSquare.rotate(PI * (y % 2))
            tempSquare.mouse_on_cell.connect(mouse_enters_new_cell)
            tempSquare.mouse_off_cell.connect(mouse_exits_current_cell)
            add_child(tempSquare)
            tempRow.append(tempSquare)

        # Builds up array of grid cells
        gridCells.append(tempRow)

        # Builds up array to store game items in each grid cell
        var tempArray : Array[GameItem] = []
        tempArray.resize(gridColumnsCount)
        gridCellsContents.append(tempArray)

    # Places the main ship to defend onto the grid
    place_item_on_grid(shipColumn,shipRow,shipPlaceableItem)
    mainShipNode = get_item_on_grid(shipColumn,shipRow)

func place_item_on_grid(row : int, column : int , item : placeableItem) -> bool:
    if gridCellsContents[row][column] != null:
        return false

    var tempItemNode : GameItem = item.scene.instantiate() as GameItem
    tempItemNode.position = get_cell_position(row,column)

    tempItemNode.gridRow = row
    tempItemNode.gridColumn = column

    add_child(tempItemNode)
    gridCellsContents[row][column] = tempItemNode

    tempItemNode.gameItemDestroyed.connect(remove_item_from_grid)

    return true

func remove_item_from_grid(row : int, column : int) -> void:
    gridCellsContents[row][column] = null

func get_item_on_grid(row : int, column : int) -> GameItem:
    return gridCellsContents[row][column]

func get_cell_position(row : int, column : int) -> Vector2:
    return gridCells[row][column].position

# Attempts to power up an item on the grid, returns true if successful, returns false if unsuccessful
func powerup_item_on_grid(row : int, column : int) -> bool:
    var gameItem : GameItem = get_item_on_grid(row, column)

    # Check if gameitem furfills the conditions to be powered up
    if gameItem == null:
        return false

    if gameItem == mainShipNode:
        return false

    if gameItem.currentlyUpgraded:
        return false

    # Checks if its possible
    if !set_scale_of_item(row, column, gameItem.upgradeSize):
        return false


    gameItem.upgrade()
    gameItem.currentlyUpgraded = true

    # Sets the game item on the grid to be powered down after 5 seconds havbe passed by calling a function
    var powerDown := Callable(self, "powerdown_item_on_grid").bind(row,column)
    get_tree().create_timer(5).timeout.connect(powerDown)

    return true

func powerdown_item_on_grid(row : int, column : int) -> void:
    var gameItem : GameItem = get_item_on_grid(row, column)
    if gameItem == null:
        return
    if gameItem.is_queued_for_deletion():
        return
    gameItem.degrade()
    gameItem.currentlyUpgraded = false
    set_scale_of_item(row, column, 1)

# Trys to scale up an item on the grid in a valid way so it doesn't occupy cells that already contain items,
#  returns true if successful and false if note
func set_scale_of_item(row : int, column : int, itemScale : int) -> bool:
    var gameItem : GameItem = get_item_on_grid(row, column)
    var scaleCorner : Vector2 = get_valid_scale_pos(row, column, itemScale)

    # If itemScale is 1, run a different procedure to treturn the item to its original scale
    if itemScale == 1:
        gameItem.position = get_cell_position(row,column)
        gameItem.scale = Vector2(1,1)

        # Remove gameitem from every cell except original position
        for y in range(0, gridColumnsCount):
            for x in range(0, gridRowsCount):
                print(Vector2(y,x))
                if x == gameItem.gridColumn && y == gameItem.gridRow:
                    continue
                if get_item_on_grid(y,x) != gameItem:
                    continue
                gridCellsContents[y][x] = null
        return true



    # Check for failure of finding a possible corner position for the scaled up gameitem
    if scaleCorner == Vector2(-1, -1):
        return false


    # Add game item to every grid cell which it now spans over
    for y in range(scaleCorner.y, scaleCorner.y + itemScale):
        for x in range(scaleCorner.x, scaleCorner.x + itemScale):
            print(Vector2(x,y))
            gridCellsContents[x][y] = gameItem

    # Correctly position and scale the game item on screen to correspond to scale up
    gameItem.position = get_cell_position(scaleCorner.x,scaleCorner.y)
    gameItem.scale = Vector2(itemScale,itemScale)
    gameItem.position += Vector2(125 * (itemScale - 2) + 62.5, 125 * (itemScale - 2) + 62.5)

    return true

# Returns a valid position for the corner of the scaled up game item, if no valid position, return a (-1,-1) Vector
func get_valid_scale_pos(row : int, column : int, itemScale : int) -> Vector2:

    var gameItem : GameItem = get_item_on_grid(row, column)

    # middle check
    if check_scale_pos(row,column,itemScale,gameItem):
        return Vector2(row,column)
    # top left
    if check_scale_pos(row - itemScale + 1,column - itemScale + 1,itemScale,gameItem):
        return Vector2(row - itemScale + 1,column - itemScale + 1)

    # top middle
    if check_scale_pos(row - itemScale + 1,column,itemScale,gameItem):
        return Vector2(row - itemScale + 1,column)

    # middle left
    if check_scale_pos(row,column - itemScale + 1,itemScale,gameItem):
        return Vector2(row,column - itemScale + 1)


    return Vector2(-1,-1)

# Checks if a scale up corner position for a game item is valid (none of the grid cells it would span already contain an item)
func check_scale_pos(row : int, column : int, itemScale : int, gameItem : GameItem) -> bool:


    if row < 0 || column < 0:
        return false

    print(column + itemScale - 1)
    print(gridColumnsCount)
    if (row + itemScale - 1 >= gridRowsCount) || (column + itemScale - 1 >= gridColumnsCount) :
        return false


    for x in range(column, column + itemScale):
        for y in range(row, row + itemScale):
            if x == gameItem.gridColumn && y == gameItem.gridRow:
                continue

            if get_item_on_grid(y,x) != null:
                return false

    return true