import numpy as np


MAZE = np.array([
  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
  [1, 0, 0, 0, 1, 0, 0, 0, 0, 1],
  [1, 0, 1, 0, 1, 0, 1, 1, 0, 1],
  [1, 0, 1, 0, 0, 0, 0, 1, 0, 1],
  [1, 0, 1, 1, 1, 1, 0, 1, 0, 1],
  [1, 0, 0, 0, 0, 0, 0, 0, 0, 1],
  [1, 1, 0, 1, 1, 0, 1, 1, 0, 1],
  [1, 0, 0, 0, 1, 0, 0, 0, 0, 1],
  [1, 0, 1, 0, 0, 0, 1, 0, 0, 1],
  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
], dtype=bool)


class AlienEnvironment:
  """Maze pursuit with eggs, pulsars, and three vulnerable Alien enemies."""

  score_cap = 35.0

  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = 500):
    self.sticky_action_prob = sticky_action_prob
    self.horizon = horizon
    self.random = np.random.RandomState()
    self.seed(0)
    self.reset()

  @classmethod
  def normalize_score(cls, raw_score: float) -> float:
    return min(max(raw_score, 0.0), cls.score_cap) / cls.score_cap

  def seed(self, seed: int) -> None:
    self.random.seed(seed)

  def reset(self) -> None:
    self.player = [8, 5]
    self.previous_player = self.player.copy()
    self.aliens = [[1, 1], [1, 8], [7, 1]]
    self.previous_aliens = [position.copy() for position in self.aliens]
    passages = [tuple(position) for position in np.argwhere(~MAZE)]
    reserved = {tuple(self.player), *(tuple(position) for position in self.aliens)}
    self.pulsars = {(3, 3), (5, 8), (8, 1)}
    self.eggs = {position for position in passages if position not in reserved | self.pulsars}
    self.eggs = set(sorted(self.eggs)[:20])
    self.power_timer = 0
    self.last_action = 0
    self.steps = 0
    self.terminal = False

  def act(self, action: int) -> tuple[float, bool]:
    if self.terminal:
      return 0.0, True
    if self.random.rand() < self.sticky_action_prob:
      action = self.last_action
    self.last_action = action
    self.previous_player = self.player.copy()
    delta = {1: (0, -1), 2: (-1, 0), 3: (0, 1), 4: (1, 0)}.get(action, (0, 0))
    target = [self.player[0] + delta[0], self.player[1] + delta[1]]
    if not MAZE[*target]:
      self.player = target

    reward = 0.0
    position = tuple(self.player)
    if position in self.eggs:
      self.eggs.remove(position)
      reward += 1.0
    if position in self.pulsars:
      self.pulsars.remove(position)
      self.power_timer = 30

    self.previous_aliens = [alien.copy() for alien in self.aliens]
    for alien in self.aliens:
      self._move_alien(alien)
    defeated = []
    for alien in self.aliens:
      if alien == self.player:
        if self.power_timer > 0:
          reward += 5.0
          defeated.append(alien)
        else:
          self.terminal = True
    for alien in defeated:
      self.aliens.remove(alien)
    self.power_timer = max(0, self.power_timer - 1)
    self.steps += 1
    if not self.eggs:
      self.terminal = True
    if self.steps >= self.horizon:
      self.terminal = True
    return reward, self.terminal

  def _move_alien(self, alien: list[int]) -> None:
    candidates = []
    for row_delta, column_delta in ((0, -1), (-1, 0), (0, 1), (1, 0)):
      candidate = [alien[0] + row_delta, alien[1] + column_delta]
      if not MAZE[*candidate]:
        distance = abs(candidate[0] - self.player[0]) + abs(candidate[1] - self.player[1])
        candidates.append((distance, self.random.rand(), candidate))
    if candidates:
      alien[:] = min(candidates)[2]

  def state(self) -> np.ndarray:
    state = np.zeros((10, 10, 6), dtype=bool)
    state[*self.player, 0] = True
    for alien in self.aliens:
      state[*alien, 1] = True
    for egg in self.eggs:
      state[*egg, 2] = True
    for pulsar in self.pulsars:
      state[*pulsar, 3] = True
    for previous in self.previous_aliens:
      state[*previous, 4] = True
    state[9, : min(10, (self.power_timer + 2) // 3), 5] = True
    return state