use crate::marble_engine::Pos;

pub type MarbleValue = u32;

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Tile {
	Open(OpenTile, MarbleTarget),
	Block,
	Marble { value: MarbleValue, dir: Direction },
	Mirror(MirrorType),
	Arrow(Direction),
	Powerable(PTile, bool),
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum MarbleTarget {
	Free,
	ClaimedIndirect,
	Claimed,
	BlockedIndirect,
	Blocked,
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum OpenTile {
	Blank,
	Digit(u8),
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum PTile {
	Trigger,
	Wire(WireType),
	Gate(GateType),
	Math(MathOp),
	Bag,
	Flipper,
	IO,
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum MirrorType {
	Forward,
	Back,
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum MathOp {
	Add,
	Sub,
	Mul,
	Div,
	Rem,
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum GateType {
	LessThan,
	GreaterThan,
	Equal,
	NotEqual,
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum WireType {
	Vertical,
	Horizontal,
	Cross,
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Direction {
	Up,
	Down,
	Left,
	Right,
}

impl Default for Tile {
	fn default() -> Self {
		Tile::Open(OpenTile::Blank, MarbleTarget::Free)
	}
}

impl Tile {
	pub const fn from_char(c: char) -> Tile {
		match c {
			'o' => Tile::Marble {
				value: 0,
				dir: Direction::Down,
			},
			'*' => Tile::Powerable(PTile::Trigger, false),
			'-' => Tile::Powerable(PTile::Wire(WireType::Horizontal), false),
			'|' => Tile::Powerable(PTile::Wire(WireType::Vertical), false),
			'+' => Tile::Powerable(PTile::Wire(WireType::Cross), false),
			'/' => Tile::Mirror(MirrorType::Forward),
			'\\' => Tile::Mirror(MirrorType::Back),
			'^' => Tile::Arrow(Direction::Up),
			'v' => Tile::Arrow(Direction::Down),
			'<' => Tile::Arrow(Direction::Left),
			'>' => Tile::Arrow(Direction::Right),
			'=' => Tile::Powerable(PTile::Gate(GateType::Equal), false),
			'!' => Tile::Powerable(PTile::Gate(GateType::NotEqual), false),
			'L' => Tile::Powerable(PTile::Gate(GateType::LessThan), false),
			'G' => Tile::Powerable(PTile::Gate(GateType::GreaterThan), false),
			'I' | 'P' => Tile::Powerable(PTile::IO, false),
			'F' => Tile::Powerable(PTile::Flipper, false),
			'A' => Tile::Powerable(PTile::Math(MathOp::Add), false),
			'S' => Tile::Powerable(PTile::Math(MathOp::Sub), false),
			'M' => Tile::Powerable(PTile::Math(MathOp::Mul), false),
			'D' => Tile::Powerable(PTile::Math(MathOp::Div), false),
			'R' => Tile::Powerable(PTile::Math(MathOp::Rem), false),
			'B' => Tile::Powerable(PTile::Bag, false),
			d @ '0'..='9' => Tile::Open(OpenTile::Digit(d as u8 - b'0'), MarbleTarget::Free),
			'#' => Tile::Block,
			_ => Tile::Open(OpenTile::Blank, MarbleTarget::Free),
		}
	}

	pub fn to_char(self) -> char {
		match self {
			Tile::Open(OpenTile::Blank, _) => ' ',
			Tile::Block => '#',
			Tile::Marble { value: _, dir: _ } => 'o',
			Tile::Open(OpenTile::Digit(n), _) => (b'0' + n) as char,
			Tile::Mirror(dir) => match dir {
				MirrorType::Forward => '/',
				MirrorType::Back => '\\',
			},
			Tile::Arrow(dir) => match dir {
				Direction::Up => '^',
				Direction::Down => 'v',
				Direction::Left => '<',
				Direction::Right => '>',
			},
			Tile::Powerable(tile, _) => match tile {
				PTile::Trigger => '*',
				PTile::Wire(wire) => match wire {
					WireType::Vertical => '|',
					WireType::Horizontal => '-',
					WireType::Cross => '+',
				},
				PTile::Gate(gate) => match gate {
					GateType::LessThan => 'L',
					GateType::GreaterThan => 'G',
					GateType::Equal => '=',
					GateType::NotEqual => '!',
				},
				PTile::Math(math) => match math {
					MathOp::Add => 'A',
					MathOp::Sub => 'S',
					MathOp::Mul => 'M',
					MathOp::Div => 'D',
					MathOp::Rem => 'R',
				},
				PTile::Bag => 'B',
				PTile::Flipper => 'F',
				PTile::IO => 'I',
			},
		}
	}

	pub fn is_blank(&self) -> bool {
		matches!(self, Tile::Open(OpenTile::Blank, _))
	}

	pub fn read_value(&self) -> MarbleValue {
		match self {
			Tile::Marble { value, dir: _ } => *value,
			Tile::Open(OpenTile::Digit(d), _) => *d as MarbleValue,
			_ => 0,
		}
	}

	pub fn texture(&self) -> String {
		match self {
			Tile::Open(OpenTile::Blank, _) => "",
			Tile::Block => "block",
			Tile::Marble { value: _, dir: _ } => "marble",
			Tile::Open(OpenTile::Digit(n), _) => return format!("tile_digit_{n}"),
			Tile::Mirror(mirror) => mirror.texture_name(),
			Tile::Arrow(dir) => dir.arrow_tile_texture_name(),
			Tile::Powerable(tile, state) => {
				let root = match tile {
					PTile::Trigger => "trigger",
					PTile::Wire(wire) => wire.texture_name(),
					PTile::Gate(gate) => gate.texture_name(),
					PTile::Math(math_op) => math_op.texture_name(),
					PTile::Bag => "bag",
					PTile::Flipper => "flipper",
					PTile::IO => "io_tile",
				};
				return format!("{root}_{}", if *state { "on" } else { "off" });
			}
		}
		.to_owned()
	}
}

impl Direction {
	pub const ALL: [Direction; 4] = [
		Direction::Up,
		Direction::Down,
		Direction::Left,
		Direction::Right,
	];

	pub fn opposite(&self) -> Direction {
		match self {
			Direction::Up => Direction::Down,
			Direction::Down => Direction::Up,
			Direction::Left => Direction::Right,
			Direction::Right => Direction::Left,
		}
	}

	pub fn right(&self) -> Direction {
		match self {
			Direction::Up => Direction::Right,
			Direction::Down => Direction::Left,
			Direction::Left => Direction::Up,
			Direction::Right => Direction::Down,
		}
	}

	pub fn left(&self) -> Direction {
		self.right().opposite()
	}

	pub fn step(&self, mut pos: Pos) -> Pos {
		match self {
			Direction::Up => pos.y -= 1,
			Direction::Down => pos.y += 1,
			Direction::Left => pos.x -= 1,
			Direction::Right => pos.x += 1,
		}
		pos
	}

	pub const fn arrow_tile_texture_name(&self) -> &'static str {
		match self {
			Direction::Up => "arrow_up",
			Direction::Down => "arrow_down",
			Direction::Left => "arrow_left",
			Direction::Right => "arrow_right",
		}
	}

	pub const fn arrow_texture_name(&self) -> &'static str {
		match self {
			Direction::Up => "direction_up",
			Direction::Down => "direction_down",
			Direction::Left => "direction_left",
			Direction::Right => "direction_right",
		}
	}
}

impl WireType {
	pub fn directions(self) -> &'static [Direction] {
		match self {
			WireType::Vertical => &[Direction::Up, Direction::Down],
			WireType::Horizontal => &[Direction::Left, Direction::Right],
			WireType::Cross => &Direction::ALL,
		}
	}

	pub fn next(&mut self) {
		*self = match self {
			WireType::Vertical => WireType::Horizontal,
			WireType::Horizontal => WireType::Cross,
			WireType::Cross => WireType::Vertical,
		}
	}

	pub fn prev(&mut self) {
		*self = match self {
			WireType::Vertical => WireType::Cross,
			WireType::Horizontal => WireType::Vertical,
			WireType::Cross => WireType::Horizontal,
		}
	}

	pub const fn texture_name(&self) -> &'static str {
		match self {
			WireType::Vertical => "wire_vertical",
			WireType::Horizontal => "wire_horizontal",
			WireType::Cross => "wire_cross",
		}
	}
}

impl MirrorType {
	pub fn new_dir(self, dir: Direction) -> Direction {
		match self {
			MirrorType::Forward => match dir {
				Direction::Up => Direction::Right,
				Direction::Down => Direction::Left,
				Direction::Left => Direction::Down,
				Direction::Right => Direction::Up,
			},
			MirrorType::Back => match dir {
				Direction::Up => Direction::Left,
				Direction::Down => Direction::Right,
				Direction::Left => Direction::Up,
				Direction::Right => Direction::Down,
			},
		}
	}

	pub fn flip(&mut self) {
		*self = match self {
			MirrorType::Forward => MirrorType::Back,
			MirrorType::Back => MirrorType::Forward,
		}
	}

	pub const fn texture_name(&self) -> &'static str {
		match self {
			MirrorType::Forward => "mirror_forward",
			MirrorType::Back => "mirror_back",
		}
	}
}

impl MathOp {
	pub const fn texture_name(&self) -> &'static str {
		match self {
			MathOp::Add => "add",
			MathOp::Sub => "sub",
			MathOp::Mul => "mul",
			MathOp::Div => "div",
			MathOp::Rem => "rem",
		}
	}

	pub fn next(&mut self) {
		*self = match self {
			MathOp::Add => MathOp::Sub,
			MathOp::Sub => MathOp::Mul,
			MathOp::Mul => MathOp::Div,
			MathOp::Div => MathOp::Rem,
			MathOp::Rem => MathOp::Add,
		}
	}

	pub fn prev(&mut self) {
		*self = match self {
			MathOp::Add => MathOp::Rem,
			MathOp::Sub => MathOp::Add,
			MathOp::Mul => MathOp::Sub,
			MathOp::Div => MathOp::Mul,
			MathOp::Rem => MathOp::Div,
		}
	}
}

impl GateType {
	pub const fn texture_name(&self) -> &'static str {
		match self {
			GateType::LessThan => "lt",
			GateType::GreaterThan => "gt",
			GateType::Equal => "eq",
			GateType::NotEqual => "neq",
		}
	}

	pub fn next(&mut self) {
		*self = match self {
			GateType::LessThan => GateType::GreaterThan,
			GateType::GreaterThan => GateType::Equal,
			GateType::Equal => GateType::NotEqual,
			GateType::NotEqual => GateType::LessThan,
		}
	}

	pub fn prev(&mut self) {
		*self = match self {
			GateType::LessThan => GateType::NotEqual,
			GateType::GreaterThan => GateType::LessThan,
			GateType::Equal => GateType::GreaterThan,
			GateType::NotEqual => GateType::Equal,
		}
	}
}