import arrays

pub fn Canvas.new(width int, height int) &Canvas {
	return &Canvas{
		layers: create_buffer(width, height)
	}
}

pub fn (canvas Canvas) size() (int, int) {
	return canvas.layers[0].len, canvas.layers.len
}

pub fn (canvas Canvas) string() string {
	output := buffer_to_braille(canvas.layers, dots_to_braille_rune_map)
	return arrays.join_to_string(output, '\n', |row| arrays.join_to_string(row, '',
		|character| '${character}'))
}

pub fn (mut canvas Canvas) set(x int, y int) {
	canvas.layers[y][x] = true
}

pub fn (mut canvas Canvas) unset(x int, y int) {
	canvas.layers[y][x] = false
}

pub fn (mut canvas Canvas) clear() {
	width, height := canvas.size()
	canvas.layers = create_buffer(width, height)
}

struct Canvas {
mut:
	layers [][]bool
}

const dots_to_braille = [u8(0), 3, 1, 4, 2, 5, 6, 7]
const dots_to_braille_rune_map = memoize_dots_to_braille_rune()

fn dots_to_braille_rune(dots u8) rune {
	mut mask := 0
	for index in 0 .. 8 {
		if ((dots >> index) & 1) == 1 {
			mask |= 1 << dots_to_braille[index]
		}
	}

	return rune(0x2800 + mask)
}

fn memoize_dots_to_braille_rune() [256]rune {
	mut memo := [256]rune{}

	for index in 0 .. 256 {
		memo[index] = dots_to_braille_rune(index)
	}

	return memo
}

fn buffer_to_braille(buffer [][]bool, braille_mapping [256]rune) [][]rune {
	out_rows := buffer.len / 4
	out_cols := buffer[0].len / 2
	mut output := [][]rune{len: out_rows, init: []rune{len: out_cols}}

	for row := 0; row < out_rows; row += 1 {
		row_offset := row * 4
		for column := 0; column < out_cols; column += 1 {
			col_offset := column * 2

			mut dots := u8(buffer[row_offset + 0][col_offset + 0])
			dots |= u8(buffer[row_offset + 0][col_offset + 1]) << 1
			dots |= u8(buffer[row_offset + 1][col_offset + 0]) << 2
			dots |= u8(buffer[row_offset + 1][col_offset + 1]) << 3
			dots |= u8(buffer[row_offset + 2][col_offset + 0]) << 4
			dots |= u8(buffer[row_offset + 2][col_offset + 1]) << 5
			dots |= u8(buffer[row_offset + 3][col_offset + 0]) << 6
			dots |= u8(buffer[row_offset + 3][col_offset + 1]) << 7

			output[row][column] = dots_to_braille_rune(dots)
		}
	}

	return output
}

fn create_buffer(width int, height int) [][]bool {
	return [][]bool{len: height, init: []bool{len: width}}
}

fn test_main() {
	braille_mapping := memoize_dots_to_braille_rune()
	width, height := 40, 48
	mut canvas := Canvas.new(width, height)
	mut buffer := [][]bool{len: height, init: []bool{len: width}}

	minr := 16 * 16
	maxr := 20 * 20
	for y := 0; y < 48; y += 1 {
		for x := 0; x < width; x += 1 {
			cy := y - 24
			big_cx := x - 20
			small_cx := x - 16
			big := (big_cx * big_cx) + (cy * cy)
			small := (small_cx * small_cx) + (cy * cy)
			if small > minr && big < maxr {
				buffer[y][x] = true
				canvas.set(x, y)
			}
		}
	}

	_ := buffer_to_braille(buffer, braille_mapping)
}