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

import numpy as np
import tcod

from actions import BaseAction, MeleeAction, MovementAction, WaitAction

if TYPE_CHECKING:
	from entity import Entity

class BaseAI:
	"""Base type for monster AI, with various utilities"""
	entity: Entity

	def __init__(self, entity):
		self.entity = entity
		self.path: List[Tuple[int, int]] = []

	def process(self) -> BaseAction:
		"""Decides what action to take"""
		raise NotImplementedError()

	def generate_path_to(self, dest_x: int, dest_y: int) -> List[Tuple[int, int]]:
		#copy the walkables
		cost = np.array(self.entity.floor_map.tiles["walkable"], dtype=np.int8)

		#higher numbers deter path-finding this way
		for entity in self.entity.floor_map.entities:
			if not entity.walkable and cost[entity.x, entity.y]:
				cost[entity.x, entity.y] += 100

		graph = tcod.path.SimpleGraph(cost=cost, cardinal=10, diagonal=14)
		pathfinder = tcod.path.Pathfinder(graph)

		pathfinder.add_root((self.entity.x, self.entity.y)) #start pos

		#make the path, omitting the start pos
		path: List[List[int]] = pathfinder.path_to((dest_x, dest_y))[1:].tolist()

		#return the path, after mapping it to a list of tuples
		return [(index[0], index[1]) for index in path]


class AggressiveWhenSeen(BaseAI):
	"""
	If the player can seem me, try to approach and attack.
	Otherwise, idle.
	"""
	def process(self) -> BaseAction:
		target = self.entity.floor_map.player
		xdir = target.x - self.entity.x
		ydir = target.y - self.entity.y
		distance = max(abs(xdir), abs(ydir))

		#if the player can see me
		if self.entity.floor_map.visible[self.entity.x, self.entity.y]:
			#if I'm close enough to attack
			if distance <= 1:
				return MeleeAction(self.entity, xdir, ydir)

			self.path = self.generate_path_to(target.x, target.y)

		#if I have a path to follow
		if self.path:
			dest_x, dest_y = self.path.pop(0)
			return MovementAction(
				entity = self.entity,
				xdir = dest_x - self.entity.x,
				ydir = dest_y - self.entity.y,
			)

		#idle
		return WaitAction(self.entity)