from __future__ import annotations

import random
from typing import Iterator, List, Tuple, TYPE_CHECKING

import tcod

from game_map import GameMap
import tile_types

if TYPE_CHECKING:
	from entity import Entity

class RectangularRoom:
	def __init__(self, x: int, y: int, width: int, height: int):
		self.x1 = x
		self.y1 = y
		self.x2 = x + width
		self.y2 = y + height
	
	@property
	def center(self) -> Tuple[int, int]:
		center_x = (self.x1 + self.x2) // 2
		center_y = (self.y1 + self.y2) // 2

		return center_x, center_y
	
	@property
	def inner(self) -> Tuple[slice, slice]:
		return slice(self.x1 + 1, self.x2), slice(self.y1 + 1, self.y2)

	def intersects(self, other: RectangularRoom) -> bool:
		return (
			self.x1 <= other.x2 and
			self.x2 >= other.x1 and
			self.y1 <= other.y2 and
			self.y2 >= other.y1
		)

def tunnel_between(start: Tuple[int, int], end: Tuple[int, int]) -> Iterator[Tuple[int, int]]:
	x1, y1 = start
	x2, y2 = end

	if random.random() < 0.5:
		corner_x, corner_y = x2, y1
	else:
		corner_x, corner_y = x1, y2
	
	for x, y in tcod.los.bresenham((x1, y1), (corner_x, corner_y)).tolist():
		yield x, y
	for x, y in tcod.los.bresenham((corner_x, corner_y), (x2, y2)).tolist():
		yield x, y

def generate_dungeon(room_count_max: int, room_size_min: int, room_size_max: int, map_width: int, map_height: int, player: Entity) -> GameMap:
	dungeon = GameMap(map_width, map_height)

	rooms: List[RectangularRoom] = []

	for r in range(room_count_max):
		room_width = random.randint(room_size_min, room_size_max)
		room_height = random.randint(room_size_min, room_size_max)

		x = random.randint(0, dungeon.width - room_width - 1)
		y = random.randint(0, dungeon.height - room_height - 1)

		new_room = RectangularRoom(x, y, room_width, room_height)

		if any(new_room.intersects(other_room) for other_room in rooms):
			continue
		
		dungeon.tiles[new_room.inner] = tile_types.floor

		if len(rooms) == 0:
			player.x, player.y = new_room.center
		else:
			for x, y in tunnel_between(rooms[-1].center, new_room.center):
				dungeon.tiles[x, y] = tile_types.floor
		
		rooms.append(new_room)

	return dungeon