#lang rhombus/static

export:
    Direction
    TileType
    Tile
    Chunk
    flip_block

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
    | Direction.north: Direction.south
    | Direction.north_east: Direction.south_west
    | Direction.east: Direction.west
    | Direction.south_east: Direction.north_west
    | Direction.south: Direction.north
    | Direction.south_west: Direction.north_east
    | Direction.west: Direction.east
    | Direction.north_west: Direction.south_east
    | ~else: #false

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

    method to_tile_int():
        match type
        | TileType.empty: 0
        | TileType.wall_north: 1

    method to_map() :: Map:
        {"type": to_tile_int()}

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(TileType.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

    method to_map() :: Map:
        {"width": width,
         "height": height,
         "offset_x": offset_x,
         "offset_y": offset_y,
         "tiles": for:
                    each tile :: Tile in tiles
                    tile.to_map()
                    ~into List}