use crate::TILE_TEXTURE_SIZE;
use crate::{draw_scaled_texture, Textures};

use super::tile::*;
use super::Pos;
use super::PosInt;
use raylib::prelude::*;

#[derive(Debug, Clone, PartialEq)]
pub struct Board {
	rows: Vec<Vec<Tile>>,
	width: usize,
	height: usize,
}

#[derive(Debug, Clone)]
pub struct ResizeDeltas {
	pub x_pos: usize,
	pub x_neg: usize,
	pub y_pos: usize,
	pub y_neg: usize,
}

impl Board {
	pub fn parse(source: &str) -> Self {
		let mut rows = Vec::new();

		let mut width = 0;
		for line in source.lines() {
			width = width.max(line.len());
			let mut tiles = Vec::new();
			for char in line.chars() {
				tiles.push(Tile::from_char(char));
			}
			rows.push(tiles);
		}
		for line in &mut rows {
			line.resize(width, Tile::BLANK);
		}

		Board::new(rows)
	}

	pub fn to_string(&self) -> String {
		let mut out = String::new();
		for row in &self.rows {
			for tile in row {
				out.push(tile.to_char())
			}
			out.push('\n');
		}
		out
	}

	pub fn new_empty(width: usize, height: usize) -> Self {
		let rows = vec![vec![Tile::BLANK; width]; height];
		Self {
			rows,
			width,
			height,
		}
	}

	pub fn new_single(tile: Tile) -> Self {
		Self {
			rows: vec![vec![tile]],
			width: 1,
			height: 1,
		}
	}

	pub fn new(rows: Vec<Vec<Tile>>) -> Self {
		Self {
			width: rows[0].len(),
			height: rows.len(),
			rows,
		}
	}

	pub fn count_tiles(&self) -> usize {
		let mut sum = 0;
		for row in &self.rows {
			for tile in row {
				match tile {
					Tile::Open(OpenTile::Blank, _) | Tile::Block => (),
					_ => sum += 1,
				}
			}
		}
		sum
	}

	fn in_bounds(&self, p: Pos) -> bool {
		p.x >= 0 && p.y >= 0 && p.x < self.width as PosInt && p.y < self.height as PosInt
	}

	pub fn get(&self, p: Pos) -> Option<Tile> {
		if self.in_bounds(p) {
			Some(self.rows[p.y as usize][p.x as usize])
		} else {
			None
		}
	}

	pub fn get_or_blank(&self, p: Pos) -> Tile {
		if self.in_bounds(p) {
			self.rows[p.y as usize][p.x as usize]
		} else {
			Tile::BLANK
		}
	}

	pub fn get_mut(&mut self, p: Pos) -> Option<&mut Tile> {
		if self.in_bounds(p) {
			Some(&mut self.rows[p.y as usize][p.x as usize])
		} else {
			None
		}
	}

	pub fn set(&mut self, p: Pos, tile: Tile) {
		if self.in_bounds(p) {
			self.rows[p.y as usize][p.x as usize] = tile;
		}
	}

	pub fn paste_board(&mut self, pos: Pos, source: &Board) {
		for x in 0..source.width() {
			for y in 0..source.height() {
				let offset = (x, y).into();
				if let Some(tile) = source.get(offset) {
					self.set(offset + pos, tile);
				}
			}
		}
	}

	pub fn get_rect(&self, pos: Pos, width: usize, height: usize) -> Board {
		let mut out = Board::new_empty(width, height);
		for x in 0..width {
			for y in 0..height {
				let offset = (x, y).into();
				if let Some(tile) = self.get(offset + pos) {
					out.set(offset, tile);
				}
			}
		}
		out
	}

	pub fn trim_size(&mut self, margin: usize) -> (usize, usize) {
		let (offset_x, offset_y);
		// top
		{
			let mut n = 0;
			while n < self.height && self.rows[n].iter().all(Tile::is_blank) {
				n += 1;
			}
			let trim_top = n.saturating_sub(margin);
			for _ in 0..trim_top {
				self.rows.remove(0);
			}
			offset_y = trim_top;
			self.height -= trim_top;
		}
		// bottom
		{
			let mut n = 0;
			while n < self.height && self.rows[self.height - n - 1].iter().all(Tile::is_blank) {
				n += 1;
			}
			let trim_bottom = n.saturating_sub(margin);
			for _ in 0..trim_bottom {
				self.rows.pop();
			}
			self.height -= trim_bottom;
		}
		// left
		{
			let mut n = 0;
			while n < self.width && self.rows.iter().all(|row| row[n].is_blank()) {
				n += 1;
			}
			let trim_left = n.saturating_sub(margin);
			for row in &mut self.rows {
				for _ in 0..trim_left {
					row.remove(0);
				}
			}
			offset_x = trim_left;
			self.width -= trim_left;
		}
		// right
		{
			let mut n = 0;
			while n < self.width && self.rows.iter().all(|r| r[self.width - n - 1].is_blank()) {
				n += 1;
			}
			let trim_right = n.saturating_sub(margin);
			for row in &mut self.rows {
				for _ in 0..trim_right {
					row.pop();
				}
			}
			self.width -= trim_right;
		}
		(offset_x, offset_y)
	}

	pub fn grow(&mut self, deltas: &ResizeDeltas) {
		let new_width = self.width + deltas.x_neg + deltas.x_pos;
		let new_height = self.height + deltas.y_neg + deltas.y_pos;
		let mut new_board = Board::new_empty(new_width, new_height);
		for x in 0..self.width {
			for y in 0..self.height {
				let tile = self.rows[y][x];
				new_board.rows[y + deltas.y_neg][x + deltas.x_neg] = tile;
			}
		}
		*self = new_board;
	}

	pub fn shrink(&mut self, deltas: &ResizeDeltas) {
		let new_width = self.width - deltas.x_neg - deltas.x_pos;
		let new_height = self.height - deltas.y_neg - deltas.y_pos;
		let mut new_board = Board::new_empty(new_width, new_height);
		for x in 0..new_width {
			for y in 0..new_height {
				let tile = self.rows[y + deltas.y_neg][x + deltas.x_neg];
				new_board.rows[y][x] = tile;
			}
		}
		*self = new_board;
	}

	pub fn width(&self) -> usize {
		self.width
	}

	pub fn height(&self) -> usize {
		self.height
	}

	pub fn get_marbles(&self) -> Vec<Pos> {
		let mut out = Vec::new();
		for y in 0..self.height {
			for x in 0..self.width {
				if let Tile::Marble { value: _, dir: _ } = self.rows[y][x] {
					out.push((x, y).into());
				}
			}
		}
		out
	}

	pub fn draw(&self, d: &mut RaylibDrawHandle, textures: &Textures, offset: Vector2, scale: f32) {
		let tile_size = (TILE_TEXTURE_SIZE * scale) as i32;

		let start_x = (-offset.x as i32) / tile_size - 1;
		let tile_width = d.get_screen_width() / tile_size + 2;
		let start_y = (-offset.y as i32) / tile_size - 1;
		let tile_height = d.get_screen_height() / tile_size + 2;

		for x in start_x..(start_x + tile_width) {
			for y in start_y..(start_y + tile_height) {
				let px = x * tile_size + offset.x as i32;
				let py = y * tile_size + offset.y as i32;
				if let Some(tile) = self.get((x, y).into()) {
					let texname = tile.texture();
					if texname.is_empty() {
						continue;
					}
					let texture = textures.get(texname);
					draw_scaled_texture(d, texture, px, py, scale);
				} else {
					d.draw_rectangle(px, py, tile_size, tile_size, Color::new(0, 0, 0, 80));
				}
			}
		}
	}
}