import numpy as np


class AdventureEnvironment:
  """Compact Adventure: rooms, keys, carried objects, dragon, bat, and chalice return."""

  score_cap = 1.0

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

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

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

  def reset(self) -> None:
    self.room = 0
    self.player = [8, 5]
    self.held = None
    self.items = {
      "gold_key": [0, 5, 7], "black_key": [2, 7, 7], "white_key": [4, 2, 2],
      "sword": [1, 7, 2], "chalice": [5, 2, 7], "bridge": [3, 6, 2],
      "magnet": [5, 7, 2],
    }
    self.dragons = [[2, 5, 5], [3, 3, 7], [5, 6, 6]]
    self.previous_dragons = [dragon.copy() for dragon in self.dragons]
    self.bat = [1, 2, 8]
    self.previous_bat = self.bat.copy()
    self.castles = {
      0: {"key": "gold_key", "open": False},
      2: {"key": "black_key", "open": False},
      4: {"key": "white_key", "open": False},
    }
    self.dragon_alive = [True, True, True]
    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
    dropped = False
    if action in (1, 2, 3, 4):
      dy, dx = {1: (0, -1), 2: (-1, 0), 3: (0, 1), 4: (1, 0)}[action]
      target = [min(9, max(0, self.player[0] + dy)), min(9, max(0, self.player[1] + dx))]
      if self._can_move(target):
        self.player = target
        self._change_room()
    elif action == 5 and self.held is not None:
      self.items[self.held] = [self.room, *self.player]
      self.held = None
      dropped = True

    if not dropped:
      self._collect_item()
    self._use_magnet()
    self.previous_dragons = [dragon.copy() for dragon in self.dragons]
    self.previous_bat = self.bat.copy()
    self._move_dragons()
    self._move_bat()
    castle = self.castles.get(self.room)
    if castle and self.player[0] <= 1 and self.held == castle["key"]:
      castle["open"] = True
    if self.room == 0 and self.player[0] <= 1 and self.held == "chalice" and self.castles[0]["open"]:
      self.terminal = True
      return 1.0, True
    self.steps += 1
    if self.steps >= self.horizon:
      self.terminal = True
    return 0.0, self.terminal

  def _can_move(self, target: list[int]) -> bool:
    if self.room != 3 or {self.player[0], target[0]} != {4, 5}:
      return True
    bridge = self.items.get("bridge")
    bridge_column = bridge[2] if bridge is not None and bridge[0] == 3 else None
    return self.held == "bridge" or bridge_column == target[1]

  def _change_room(self) -> None:
    if self.player[1] == 0 and self.room % 2 == 1:
      self.room -= 1
      self.player[1] = 9
    elif self.player[1] == 9 and self.room % 2 == 0:
      self.room += 1
      self.player[1] = 0
    elif self.player[0] == 0 and self.room >= 2:
      self.room -= 2
      self.player[0] = 9
    elif self.player[0] == 9 and self.room < 4:
      self.room += 2
      self.player[0] = 0

  def _collect_item(self) -> None:
    for name, location in list(self.items.items()):
      if location == [self.room, *self.player] and self.held is None:
        self.held = name
        del self.items[name]
    castle = self.castles.get(self.room)
    if castle and self.held == castle["key"] and self.player[0] <= 1:
      castle["open"] = True

  def _move_dragons(self) -> None:
    for index, dragon in enumerate(self.dragons):
      if not self.dragon_alive[index] or dragon[0] != self.room:
        continue
      _, row, column = dragon
      row += int(np.sign(self.player[0] - row))
      column += int(np.sign(self.player[1] - column))
      dragon[1:] = [row, column]
      if [row, column] == self.player:
        if self.held == "sword":
          self.dragon_alive[index] = False
        else:
          self.terminal = True

  def _use_magnet(self) -> None:
    if self.held != "magnet":
      return
    candidates = [(name, location) for name, location in self.items.items() if location[0] == self.room]
    if not candidates:
      return
    _, location = min(candidates, key=lambda item: abs(item[1][1] - self.player[0]) + abs(item[1][2] - self.player[1]))
    location[1] += int(np.sign(self.player[0] - location[1]))
    location[2] += int(np.sign(self.player[1] - location[2]))

  def _move_bat(self) -> None:
    if self.random.rand() >= 0.15:
      return
    self.bat[0] = int(self.random.randint(6))
    self.bat[1] = int(self.random.randint(10))
    self.bat[2] = int(self.random.randint(10))
    if self.bat == [self.room, *self.player] and self.held is not None:
      name = self.held
      self.held = None
      self.items[name] = self.bat.copy()

  def state(self) -> np.ndarray:
    state = np.zeros((10, 10, 6), dtype=bool)
    state[*self.player, 0] = True
    for name, (room, row, column) in self.items.items():
      if room == self.room:
        if name == "chalice":
          state[row, column, 2] = True
        else:
          state[row, column, 3] = True
          marker = {
            "gold_key": 0,
            "black_key": 1,
            "white_key": 2,
            "sword": 3,
            "bridge": 4,
            "magnet": 5,
          }[name]
          state[row, marker, 5] = True
    for alive, dragon in zip(self.dragon_alive, self.dragons, strict=True):
      if alive and dragon[0] == self.room:
        state[dragon[1], dragon[2], 1] = True
    for previous, alive in zip(self.previous_dragons, self.dragon_alive, strict=True):
      if alive and previous[0] == self.room:
        state[previous[1], previous[2], 4] = True
    if self.bat[0] == self.room:
      state[self.bat[1], self.bat[2], 1] = True
    if self.previous_bat[0] == self.room:
      state[self.previous_bat[1], self.previous_bat[2], 4] = True
    if self.room == 3:
      state[4, :, 1] = True
      bridge = self.items.get("bridge")
      if self.held == "bridge":
        state[4, self.player[1], 1] = False
      elif bridge is not None and bridge[0] == 3:
        state[4, bridge[2], 1] = False
    if self.room in self.castles:
      state[0, 4:7, 1] = not self.castles[self.room]["open"]
    if self.held is not None:
      held_marker = {
        "gold_key": 0,
        "black_key": 1,
        "white_key": 2,
        "sword": 3,
        "chalice": 4,
        "bridge": 5,
        "magnet": 6,
      }[self.held]
      state[8, held_marker, 5] = True
    state[9, self.room, 5] = True
    for castle_room, castle in self.castles.items():
      if castle["open"]:
        state[7, castle_room, 5] = True
    return state