tool
class_name Tetris
extends MarginContainer

const ROWS = 20
const COLUMNS = 10

export(PoolColorArray) var colors
export(PoolColorArray) var transcolors
export(Color) var grid_color
export(Color) var bg_color

var current_shape: TetrisPiece
var matrix := Logic.create_matrix(ROWS, COLUMNS)
var bg_squares := []
var squares := []
var nxt_p_squares := []

var bag := Logic.piece_bag.duplicate(true)
onready var next_shape: Array = bag.pop_at(randi() % len(bag))


func random_shape() -> Array:
	var n = next_shape
	next_shape = bag.pop_at(randi() % len(bag))
	if bag.empty():
		bag = Logic.piece_bag.duplicate(true)
	draw_nxt_p_shape()
	return n


func draw_nxt_p_shape():
	var clr = colors[Logic.piece_indexs[next_shape]]
	var n = [0, 0, 0, 0]
	n.append_array(next_shape.duplicate())
	for i in range(4 * 4):
		nxt_p_squares[i].color = Color.transparent
		if i > len(n) - 1 or n[i] == 0:
			continue
		nxt_p_squares[i].color = clr


func get_square(at: Vector2) -> Control:
	return squares[at.y * COLUMNS + at.x]


func init_squares(on: Control):
	var aspect = AspectRatioContainer.new()
	aspect.alignment_vertical = aspect.ALIGN_BEGIN
	aspect.ratio = float(COLUMNS) / float(ROWS)
	aspect.name = "aspect"
	expand_control(aspect)
	on.add_child(aspect)
	var sqs := create_grid_container("squares")
	aspect.add_child(sqs)
	for _i in range(ROWS * COLUMNS):
		squares.append(create_square(sqs, "%d" % _i))


func create_square(to: GridContainer, name: String, bg := true) -> ColorRect:
	var fg_square := ColorRect.new()
	fg_square.color = Color.transparent
	fg_square.name = name
	fg_square.rect_min_size = Vector2(10, 10)
	expand_control(fg_square)
	to.add_child(fg_square)
	if bg:
		var bg_square := ReferenceRect.new()
		bg_square.editor_only = false
		bg_square.border_width = 1.5
		bg_square.border_color = grid_color
		bg_square.name = name
		bg_square.show_behind_parent = true
		expand_control(bg_square)
		fg_square.add_child(bg_square)
	return fg_square


func create_grid_container(name: String, cols := COLUMNS, expand := true) -> GridContainer:
	var g := GridContainer.new()
	g.columns = cols
	g.name = name
	g.add_constant_override("vseparation", 0)
	g.add_constant_override("hseparation", 0)
	if expand:
		expand_control(g)
	return g


func expand_control(c: Control) -> void:
	c.size_flags_horizontal = SIZE_EXPAND_FILL
	c.size_flags_vertical = SIZE_EXPAND_FILL
	c.set_anchors_and_margins_preset(PRESET_WIDE)


func init_bg() -> void:
	var c := ColorRect.new()
	c.name = "bg"
	expand_control(c)
	c.color = bg_color
	add_child(c)


func init_next_preview(on: Control):
	var aspect := AspectRatioContainer.new()
	aspect.alignment_vertical = aspect.ALIGN_BEGIN
	aspect.name = "aspect"
	aspect.set_anchors_and_margins_preset(PRESET_WIDE)
	on.add_child(aspect)
	var next = create_grid_container("next-block-preview", 4, false)
	aspect.add_child(next)
	for _i in range(4 * 4):
		nxt_p_squares.append(create_square(next, "%d" % _i, false))

	var square = ReferenceRect.new()
	square.name = "next-block-outline"
	square.border_width = 1.5
	square.border_color = grid_color
	square.editor_only = false
	expand_control(square)
	aspect.add_child(square)


func _ready() -> void:
	set_process(false)
	init_bg()
	var h = HBoxContainer.new()
	h.add_constant_override("hseparation", 5)
	h.name = "hbox"
	add_child(h)
	init_squares(h)
	init_next_preview(h)
	if not Engine.editor_hint:
		start()


func start() -> void:
	set_process(true)
	# warning-ignore-all:integer_division
	current_shape = TetrisPiece.new(Vector2((COLUMNS / 2) - 2, 0), random_shape())
	tick()


func draw_board() -> void:
	var mat := matrix.duplicate(true)
	current_shape.embed(mat)
	var set_squares = draw_preview()
	for y in range(ROWS):
		for x in range(COLUMNS):
			if mat[y][x] > 0:
				get_square(Vector2(x, y)).color = colors[mat[y][x] - 1]
			elif set_squares.find(Vector2(x, y)) == -1:
				get_square(Vector2(x, y)).color = Color.transparent


func draw_preview(shape: TetrisPiece = current_shape) -> PoolVector2Array:
	var p = shape.position
	shape.fall(matrix)
	var set_squares: PoolVector2Array = []
	for y in range(4):
		for x in range(4):
			if Logic.get_index_or_null(shape.shape, y, x) > 0:
				set_squares.append(Vector2(x, y) + shape.position)
				get_square(Vector2(x, y) + shape.position).color = transcolors[shape.shape_type]
	shape.position = p
	return set_squares


func highlight_clearable_lines() -> void:
	var mat := matrix.duplicate(true)
	current_shape.embed(mat)
	var lines = Logic.clear_lines(mat.duplicate(true))
	for l in lines:
		for x in range(COLUMNS):
			var c = colors[mat[l][x] - 1]
			c.v += .2
			get_square(Vector2(x, l)).color = c


func _input(event):
	if event is InputEventSwipe:
		match event.direction.round().normalized():
			Vector2.RIGHT:
				current_shape.move(Vector2.RIGHT, matrix)
			Vector2.LEFT:
				current_shape.move(Vector2.LEFT, matrix)
			Vector2.DOWN:
				current_shape.fall(matrix)
				tick(false)
			_:
				current_shape.rotate(matrix)
				tick(false)

	if event.is_action_pressed("left", true):
		current_shape.move(Vector2.LEFT, matrix)
	elif event.is_action_pressed("right", true):
		current_shape.move(Vector2.RIGHT, matrix)
	if event.is_action_pressed("rotate_cw"):
		current_shape.rotate(matrix, true)
	elif event.is_action_pressed("rotate_anti_cw"):
		current_shape.rotate(matrix, false)
	if event.is_action_pressed("down"):
		current_shape.fall(matrix)
		tick(false)
	else:
		draw_board()


func tick(create_timer := true):
	var no_draw := false
	var t_length := .25
	if not current_shape.move(Vector2(0, 1), matrix):  # invalid move: cant go down
		if current_shape.position.y == 0:
			get_tree().reload_current_scene()
		if current_shape.stopped:
			print(ascii(matrix))
			current_shape.embed(matrix)
			current_shape = TetrisPiece.new(Vector2(randi() % (COLUMNS - 4), 0), random_shape())
			Logic.clear_lines(matrix)
		else:
			current_shape.stopped = true
			draw_board()
			highlight_clearable_lines()
			no_draw = true
			t_length = .5
	if create_timer:
		var t := get_tree().create_timer(t_length, false)
		t.connect("timeout", self, "tick")
	if not no_draw:
		draw_board()


#warning-ignore:shadowed_variable
func ascii(matrix):
	var s = "+"
	for _x in range(COLUMNS):
		s += "-"
	s += "+"
	#warning-ignore:shadowed_variable
	for y in range(ROWS):
		s += "\n" + ("|" if y != ROWS - 1 else "+")
		for x in range(COLUMNS):
			if matrix[y][x] > 0:
				s += "ﱢ"
			else:
				s += "-"
		s += ("|" if y != ROWS - 1 else "+")
	return s