#lang rhombus/static

export:
    Chunk
    Entity
    World
    Tile

enum Direction:
    north
    north_east
    east
    south_east
    south
    south_west
    west
    north_west

enum TileType:
    empty
    wall_north

fun flip_block(block :: maybe(Direction)) :: maybe(Direction):
    match block
    | #'north: #'south
    | #'north_east: #'south_west
    | #'east: #'west
    | #'south_east: #'north_west
    | #'south: #'north
    | #'south_west: #'north_east
    | #'west: #'east
    | #'north_west: #'south_east
    | ~else: #false

class Tile(type :: TileType):
    method get_block() :: maybe(Direction):
        match type
        | #'empty: #false
        | #'wall_north: #'north

class Chunk(width :: Int,
            height :: Int,
            offset_x :: Int,
            offset_y :: Int,
            tiles :: Array.now_of(Tile),
            neighbours :: MutableMap.now_of(Direction, Chunk)):
    constructor(width :: Int, height :: Int, offset_x :: Int, offset_y :: Int):
        super(width, height, offset_x, offset_y, Array.make(width * height, Tile(#'empty)), MutableMap())

    method add_neighbour(chunk :: Chunk, direction :: Direction):
        neighbours[direction] := chunk

    method get_tile(x :: Int, y :: Int) :: Tile:
        tiles[y * width + x]

    method set_tile(x :: Int, y :: Int, tile :: Tile):
        tiles[y * width + x] := tile

class Entity(id:: Int, mutable x :: Int, mutable y :: Int, mutable current_chunk :: Chunk):
    method validate_dist(x :: Int, y :: Int, max_dist :: Int):
        let diff_x = math.abs(this.x - x)
        let diff_y = math.abs(this.y - y)
        // Diagonal case is moving in the same direction (same x & y) and that amount
        // is less than or equal to max distance
        let diagonal = diff_x == diff_y && diff_x <= max_dist
        let x_axis = diff_x <= max_dist && diff_y == 0
        let y_axis = diff_y <= max_dist && diff_x == 0
        let no_movement = diff_x == 0 && diff_y == 0
        !no_movement && (diagonal || x_axis || y_axis)

    method validate_chunk(x :: Int, y :: Int) :: maybe(Chunk):
        let current_chunk = this.current_chunk
        let local_x = x - current_chunk.offset_x * current_chunk.width
        let local_y = y - current_chunk.offset_y * current_chunk.height
        let less_x = local_x < 0
        let less_y = local_y < 0
        let more_x = local_x >= current_chunk.width
        let more_y = local_y >= current_chunk.height
        let inside_x = !(less_x || more_x)
        let inside_y = !(less_y || more_y)
        let next_chunk :: maybe(Chunk) = cond
        | inside_x && less_y: current_chunk.neighbours.get(#'north, #false)
        | more_x && less_y:   current_chunk.neighbours.get(#'north_east, #false)
        | more_x && inside_y: current_chunk.neighbours.get(#'east, #false)
        | more_x && more_y:   current_chunk.neighbours.get(#'south_east, #false)
        | inside_x && more_y: current_chunk.neighbours.get(#'south, #false)
        | less_x && more_y:   current_chunk.neighbours.get(#'south_west, #false)
        | less_x && inside_y: current_chunk.neighbours.get(#'west, #false)
        | less_x && less_y:   current_chunk.neighbours.get(#'north_west, #false)
        | ~else:              current_chunk

        next_chunk

    method validate_move(x :: Int, y :: Int, max_dist :: Int, target_chunk :: Chunk):
        let current_tile = this.current_chunk.get_tile(this.x, this.y)
        let target_tile = target_chunk.get_tile(x, y)
        let diff_x = x - this.x
        let diff_y = y - this.y
        let direction = cond
        | diff_x == 0 && diff_y < 0:  #'north
        | diff_x > 0  && diff_y < 0:  #'north_east
        | diff_x > 0  && diff_y == 0: #'east
        | diff_x > 0  && diff_y > 0:  #'south_east
        | diff_x == 0 && diff_y > 0:  #'south
        | diff_x < 0 && diff_y > 0:   #'south_west
        | diff_x < 0  && diff_y == 0: #'west
        | diff_x < 0  && diff_y < 0:  #'north_west
        let current_block = current_tile.get_block()
        let target_block = flip_block(target_tile.get_block())
        !(direction == current_block || direction == target_block)

    method
    | move(x :: Int, y :: Int): move(x, y, 1)
    | move(x :: Int, y :: Int, max_dist :: Int) :: Boolean:
        let target_chunk = validate_chunk(x, y)

        cond
        | validate_dist(x, y, max_dist) && target_chunk != #false && validate_move(x, y, max_dist, target_chunk!!):
            this.current_chunk := target_chunk!!
            this.x := x
            this.y := y
            #true
        | ~else:
            #false

    method gather(target_entity :: Entity):
        let x = target_entity.x
        let y = target_entity.y
        let target_chunk = validate_chunk(x, y)

        fun validate_gather_resource() :: Boolean:
            // TODO figure out how to implement resource gathering
            // it could be better to keep them as a tile and update the
            // tile from regular to consumed
            #false

        cond
        | validate_dist(x, y, 1) && target_chunk != #false && validate_gather_resource():
            #true
        | ~else:
            #false

class World(chunks :: MutableList.now_of(Chunk),
            entities :: MutableList.now_of(Entity)):

    constructor():
        super(MutableList(), MutableList())