from __future__ import annotations
from typing import List, Optional, TYPE_CHECKING

import tcod

import colors
from actions import (
	BaseAction,
	QuitAction,
	BumpAction,
	WaitAction,
	PickupAction,
	DropAction,
	DropPartialStackAction,
	UsageAction,
)

if TYPE_CHECKING:
	from engine import Engine
	from entity import Entity

#input options
MOVE_KEYS = {
	#arrow keys
	tcod.event.KeySym.UP: (0, -1),
	tcod.event.KeySym.DOWN: (0, 1),
	tcod.event.KeySym.LEFT: (-1, 0),
	tcod.event.KeySym.RIGHT: (1, 0),

	tcod.event.KeySym.HOME: (-1, -1),
	tcod.event.KeySym.END: (-1, 1),
	tcod.event.KeySym.PAGEUP: (1, -1),
	tcod.event.KeySym.PAGEDOWN: (1, 1),

	#numpad keys
	tcod.event.KeySym.KP_1: (-1, 1),
	tcod.event.KeySym.KP_2: (0, 1),
	tcod.event.KeySym.KP_3: (1, 1),
	tcod.event.KeySym.KP_4: (-1, 0),

	tcod.event.KeySym.KP_6: (1, 0),
	tcod.event.KeySym.KP_7: (-1, -1),
	tcod.event.KeySym.KP_8: (0, -1),
	tcod.event.KeySym.KP_9: (1, -1),

	#vi key mapping
	tcod.event.KeySym.h: (-1, 0),
	tcod.event.KeySym.j: (0, 1),
	tcod.event.KeySym.k: (0, -1),
	tcod.event.KeySym.l: (1, 0),

	tcod.event.KeySym.y: (-1, -1),
	tcod.event.KeySym.u: (1, -1),
	tcod.event.KeySym.b: (-1, 1),
	tcod.event.KeySym.n: (1, 1),
}

WAIT_KEYS = {
	tcod.event.KeySym.PERIOD,
	tcod.event.KeySym.KP_5,
	tcod.event.KeySym.CLEAR,
}

PICKUP_KEYS = {
	tcod.event.KeySym.COMMA,
}

CURSOR_SCROLL_KEYS = {
	tcod.event.KeySym.UP: -1,
	tcod.event.KeySym.DOWN: 1,
	tcod.event.KeySym.PAGEUP: -10,
	tcod.event.KeySym.PAGEDOWN: 10,

	tcod.event.KeySym.KP_2: 1,
	tcod.event.KeySym.KP_8: -1,
}

CURSOR_CONFIRM_KEYS = {
	tcod.event.KeySym.RETURN,
	tcod.event.KeySym.SPACE,
}

#the event handlers are a big part of the engine
class EventHandler(tcod.event.EventDispatch[BaseAction]):
	engine: Engine
	parent_handler: EventHandler

	def __init__(self,engine: Engine, parent_handler: EventHandler):
		super().__init__()
		self.engine = engine
		self.parent_handler = parent_handler

	def render(self, console: tcod.console.Console) -> None:
		if self.parent_handler:
			self.parent_handler.render(console)

	#callbacks
	def ev_quit(self, event: tcod.event.Quit) -> Optional[BaseAction]:
		return QuitAction()

	def handle_events(self, context: tcod.context.Context) -> bool:
		"""If any Action signals True, then the game state should be progressed after this"""
		result = False

		for event in tcod.event.wait():
			context.convert_event(event) #adds mouse position info
			action = self.dispatch(event)

			if action is None:
				continue

			result |= action.perform()

		return result


class GameplayHandler(EventHandler):
	def ev_keydown(self, event: tcod.event.KeyDown) -> Optional[BaseAction]:
		key = event.sym #SDL stuff, neat.

		player = self.engine.player

		#special keys
		if key == tcod.event.KeySym.ESCAPE:
			return QuitAction()

		#gameplay keys
		if key in MOVE_KEYS:
			xdir, ydir = MOVE_KEYS[key]
			return BumpAction(player, xdir = xdir, ydir = ydir)

		if key in WAIT_KEYS:
			return WaitAction(player)

		if key in PICKUP_KEYS:
			return PickupAction(player)

		#menu keys
		if key == tcod.event.KeySym.BACKQUOTE: #lowercase tilde
			self.engine.event_handler = LogHistoryViewer(self.engine, self)

		if key == tcod.event.KeySym.TAB:
			self.engine.event_handler = InventoryViewer(self.engine, self, player)

		#debugging - can hook this up to more later
		if (event.mod & tcod.event.Modifier.CTRL) and key == tcod.event.KeySym.d:
			self.engine.event_handler = OptionSelector(
				self.engine,
				self,
				title="Debug Selector",
				options=["Zero", "One", "Two", "Three"],
				callback=lambda x: self.engine.message_log.add_message(f"DBG: You selected {x}", colors.orange),
				margin_x=20,
				margin_y=12,
			)

	def ev_mousemotion(self, event: tcod.event.MouseMotion) -> None:
		if self.engine.floor_map.in_bounds(event.tile.x, event.tile.y):
			self.engine.mouse_location = event.tile.x, event.tile.y


class GameOverHandler(EventHandler):
	"""Game over, man, GAME OVER!"""
	def ev_keydown(self, event: tcod.event.KeyDown) -> Optional[BaseAction]:
		key = event.sym #SDL stuff, neat.

		#player input
		if key == tcod.event.KeySym.ESCAPE:
			return QuitAction()

		if key == tcod.event.KeySym.BACKQUOTE: #lowercase tilde
			self.engine.event_handler = LogHistoryViewer(self.engine, self)

		return None


class LogHistoryViewer(EventHandler):
	def __init__(self, engine: Engine, parent_handler: EventHandler):
		super().__init__(engine, parent_handler)
		self.length = len(engine.message_log.messages)
		self.cursor = self.length - 1 #start at the bottom

	def render(self, console: tcod.console.Console) -> None:
		super().render(console)

		log_console = tcod.console.Console(console.width - 6, console.height - 6)

		#rendering a nice window
		log_console.draw_frame(
			0,0, log_console.width, log_console.height,
			# "╔═╗║ ║╚═╝"
			decoration="\\x/x x/x\\",
			fg=colors.terminal_dark, bg=colors.black
		)
		log_console.print_box(
			0, 0, log_console.width, log_console.height,
			string = "Message History",
			alignment=tcod.constants.CENTER,
			fg=colors.terminal_light, bg=colors.black
		)
		self.engine.message_log.render_messages(
			log_console,
			2, 2,
			log_console.width - 4, log_console.height - 4,
			self.engine.message_log.messages[:self.cursor + 1]
		)

		log_console.blit(console, 3, 3)

	def ev_keydown(self, event: tcod.event.KeyDown) -> Optional[BaseAction]:
		if event.sym in CURSOR_SCROLL_KEYS:
			adjust = CURSOR_SCROLL_KEYS[event.sym]
			if adjust < 0 and self.cursor == 0:
				pass #do nothing
			elif adjust > 0 and self.cursor == self.length - 1:
				pass #do nothing
			else:
				self.cursor = max(0, min(self.length - 1, self.cursor + adjust))

		elif event.sym == tcod.event.KeySym.HOME:
			self.cursor = 0
		elif event.sym == tcod.event.KeySym.END:
			self.cursor = self.length - 1
		else:
			#return to the game - where's the any key?
			self.engine.event_handler = self.parent_handler


class InventoryViewer(EventHandler):
	def __init__(self, engine: Engine, parent_handler: EventHandler, entity: Entity): #this entity's inventory
		super().__init__(engine, parent_handler)
		self.entity = entity
		self.length = len(self.entity.inventory.contents)
		self.cursor = 0

	def render(self, console: tcod.console.Console) -> None:
		super().render(console)

		inner_console = tcod.console.Console(console.width - 6, console.height - 6)

		#rendering a nice window
		inner_console.draw_frame(
			0,0, inner_console.width, inner_console.height,
			# "╔═╗║ ║╚═╝"
			decoration="\\x/x x/x\\",
			fg=colors.terminal_dark, bg=colors.black
		)
		inner_console.print_box(
			0, 0, inner_console.width, inner_console.height,
			string = "Inventory",
			alignment=tcod.constants.CENTER,
			fg=colors.terminal_light, bg=colors.black
		)

		#render the cursor & inventory contents
		offset: int = 0
		for item in self.entity.inventory.contents:
			msg = item.name
			if item.useable.current_stack > 1:
				msg = f"{msg} x{item.useable.current_stack}"
			inner_console.print(
				4, 2 + offset,
				string = msg,
				fg=colors.terminal_light, bg=colors.black,
			)
			offset += 2

		if self.length > 0:
			inner_console.print(2, 2 + self.cursor * 2, string = ">", fg=colors.terminal_light, bg=colors.black)
		else:
			#if inventory is empty, show a default message
			inner_console.print_box(
				0,inner_console.height // 2, inner_console.width, inner_console.height,
				string = "EMPTY",
				fg=colors.terminal_dark, bg=colors.black,
				alignment=tcod.constants.CENTER
			)

		inner_console.blit(console, 3, 3)

	def ev_keydown(self, event: tcod.event.KeyDown) -> Optional[BaseAction]:
		if event.sym in CURSOR_SCROLL_KEYS:
			adjust = CURSOR_SCROLL_KEYS[event.sym]
			if adjust < 0 and self.cursor == 0:
				pass #do nothing
			elif adjust > 0 and self.cursor == self.length - 1:
				pass #do nothing
			else:
				self.cursor = max(0, min(self.length - 1, self.cursor + adjust))

		#extra size check, so empty inventories still work
		elif self.length > 0 and event.sym in CURSOR_CONFIRM_KEYS:
			#drop an item form this entity's inventory
			item: Entity = self.entity.inventory.access(self.cursor)

			#defaults
			options = ["Use", "Drop", "Back"]
			callback = lambda x: self.default_selector_callback(x)

			#different options for different situations
			if item.useable.current_stack > 1:
				options = ["Use", "Drop 1", "Drop All", "Back"]
				callback = lambda x: self.stack_selector_callback(x)

			#TODO: drop 1, drop all for stacks
			self.engine.event_handler = OptionSelector(
				self.engine,
				self,
				title=item.name,
				options=options,
				callback=callback,
				margin_x=20,
				margin_y=12,
			)

		#TODO: hotkeys via a config

		elif event.sym == tcod.event.KeySym.HOME:
			self.cursor = 0
		elif event.sym == tcod.event.KeySym.END:
			self.cursor = self.length - 1
		else:
			#return to the game - where's the any key?
			self.engine.event_handler = self.parent_handler

	#utils
	def default_selector_callback(self, selected: int) -> Optional[BaseAction]:
		if selected == 0: #Use
			return self.use()
		elif selected == 1: #Drop
			return self.drop()
		elif selected == 2: #Back
			return None #the selector does the change

	def stack_selector_callback(self, selected: int) -> Optional[BaseAction]:
		if selected == 0: #Use
			return self.use()
		elif selected == 1: #Drop 1
			return self.drop_partial_stack(1)
		elif selected == 2: #Drop all
			return self.drop()
		elif selected == 3: #Back
			return None #the selector does the change

	def use(self) -> Optional[BaseAction]:
		"""Drop the item at the cursor's position, and adjust the cursor if needed."""
		if self.length > 0:
			index = self.cursor

			return UsageAction(self.entity, index, self.entity, lambda x: self.adjust_length(x))

	def drop_partial_stack(self, amount: int) -> Optional[BaseAction]:
		"""Drop part of an item stack at the cursor's position, and adjust the cursor if needed."""
		if self.length > 0:
			index = self.cursor

			return DropPartialStackAction(self.entity, index, amount, lambda x: self.adjust_length(x))

	def drop(self) -> Optional[BaseAction]:
		"""Drop the item at the cursor's position, and adjust the cursor if needed."""
		if self.length > 0:
			index = self.cursor

			return DropAction(self.entity, index, lambda x: self.adjust_length(x))

	def adjust_length(self, amount: int):
		self.length += amount
		if self.cursor >= self.length:
			self.cursor = self.length - 1


#generic tools
class OptionSelector(EventHandler):
	def __init__(
			self,
			engine: Engine,
			parent_handler: EventHandler,
			*,
			options: List[str],
			callback: function,
			title: str = "Select Option",
			margin_x: int = 10,
			margin_y: int = 8
	):
		super().__init__(engine, parent_handler)
		self.options = options
		self.callback = callback
		self.length = len(options)
		self.cursor = 0

		#graphical prettiness
		self.title = title
		self.margin_x = margin_x
		self.margin_y = margin_y

	def render(self, console: tcod.console.Console) -> None:
		super().render(console)

		select_console = tcod.console.Console(console.width - self.margin_x*2, console.height - self.margin_y*2)

		#rendering a nice window
		select_console.draw_frame(
			0,0, select_console.width, select_console.height,
			# "╔═╗║ ║╚═╝"
			decoration="\\x/x x/x\\",
			fg=colors.terminal_dark, bg=colors.black
		)
		select_console.print_box(
			0, 0, select_console.width, select_console.height,
			string = self.title,
			alignment=tcod.constants.CENTER,
			fg=colors.terminal_light, bg=colors.black
		)

		#render the cursor & options
		offset: int = 0
		for option in self.options:
			select_console.print(
				4, 2 + offset,
				string = option,
				fg=colors.terminal_light, bg=colors.black,
			)
			offset += 2

		select_console.print(2, 2 + self.cursor * 2, string = ">", fg=colors.terminal_light, bg=colors.black)

		select_console.blit(console, self.margin_x, self.margin_y)

	def ev_keydown(self, event: tcod.event.KeyDown) -> Optional[BaseAction]:
		if event.sym in CURSOR_SCROLL_KEYS:
			adjust = CURSOR_SCROLL_KEYS[event.sym]
			if adjust < 0 and self.cursor == 0:
				pass #do nothing
			elif adjust > 0 and self.cursor == self.length - 1:
				pass #do nothing
			else:
				self.cursor = max(0, min(self.length - 1, self.cursor + adjust))

		elif event.sym in CURSOR_CONFIRM_KEYS:
			self.engine.event_handler = self.parent_handler
			return self.callback(self.cursor)

		elif event.sym == tcod.event.KeySym.HOME:
			self.cursor = 0
		elif event.sym == tcod.event.KeySym.END:
			self.cursor = self.length - 1
		else:
			#return to the game
			self.engine.event_handler = self.parent_handler