use comfy::*;

use super::grid::Grid;

#[derive(Debug)]
enum RoomType {
	Kitchen,
	Bath,
	Toilett,
	LivingRoom,
	SleepingRoom
}

#[derive(Debug)]
pub struct Room {
	room_type: RoomType,
	pub size: (u8, u8), //(width, height)
	pub grid: Grid
}

impl RoomType {
	pub fn random() -> Self {
		match random_i32(0, 4) {
			0 => RoomType::Kitchen,
			1 => RoomType::Bath,
			2 => RoomType::Toilett,
			3 => RoomType::LivingRoom,
			4 => RoomType::SleepingRoom,
			_ => panic!("Somehow you where unlucky and got a random number out of range")
		}
	}
}

impl Default for Room {
	fn default() -> Self {
		Room::load() //Just for testing purposes
	}
}

impl Room {
    pub fn load() -> Self {
		let room_type = RoomType::random();
		let size = Self::random_size(&room_type);

        Room { room_type, size, grid: Self::create_grid(size.0, size.1)}
    }

	fn random_size(room_type: &RoomType) -> (u8, u8) {
		match room_type {
			RoomType::Kitchen | RoomType::LivingRoom => {
				(random_i32(5, 8) as u8, 3)
			}
			RoomType::Bath | RoomType::SleepingRoom => {
				(random_i32(4, 6) as u8, 3)
			}
			RoomType::Toilett => {
				(random_i32(2, 3) as u8, 3)
			}
		}
	}

	fn create_grid(width: u8, height: u8) -> Grid{
		error!("START GRID CREATION!");
		let left_border = width as f32 / 2.0;
		let lower_border = height as f32 / 2.0;
		let scale = 4.0;

		//Lower Cable
		let lower_cable_y = height as f32 / 6.0;
		let mut current_x = -0.5;

		let mut nodes = Vec::new();
		let max_offset = ((width / 2) as i32).max(1);

		while current_x < width as f32 {
			nodes.push(vec2((current_x - left_border) * scale, (lower_cable_y - lower_border) * scale));
			current_x += random_i32(1, max_offset) as f32;
		}
		current_x = width as f32 + 0.5;
		nodes.push(vec2((current_x - left_border) * scale, (lower_cable_y - lower_border) * scale));

		let mut connections = Vec::new();
		for i in 1..nodes.len() {
			connections.push((i-1, i));
		}

		//Lamps
		let upper_cable_y = height as f32 - 0.25;
		let max_lamps = (width as f32 / 2.5).round() as i32;
		let lamp_amount = random_i32(1, max_lamps + 1);
		let node_indices: HashSet<usize> = (0..lamp_amount).map(|_| random_i32(1, nodes.len() as i32 - 1) as usize).collect();
		
		let last_lower_node_index = nodes.len();
		for (i, index) in node_indices.iter().enumerate() {
			nodes.push(vec2(nodes.get(*index).unwrap().x,(upper_cable_y - lower_border) * scale));
			connections.push((*index, last_lower_node_index + i));
		}

		Grid::new(nodes, connections)
	}

	pub fn draw(&self) {
		let scale = 4.0;
		let (width, height) = self.size;
		let (width, height) = (width as f32 * scale, height as f32  * scale);

		draw_rect_outline(vec2(0.0, 0.0), vec2(width, height), 0.3, RED, 0);

		self.grid.draw();
	}
}