import numpy as np


INITIAL_MUSHROOMS = (
  (1, 1), (1, 5), (1, 8), (2, 3), (2, 7),
  (3, 1), (3, 5), (3, 9), (4, 2), (4, 6),
  (5, 0), (5, 4), (5, 8), (6, 2), (6, 7),
)


class CentipedeEnvironment:
  """Four-wave mushroom-field shooter with splitting chains and specialist insects."""

  score_cap = 9_528.0

  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = 2_000):
    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 = [9, 5]
    self.previous_player = self.player.copy()
    self.shot: list[int] | None = None
    self.mushrooms = {position: {"health": 3, "poisoned": False} for position in INITIAL_MUSHROOMS}
    self.lives = 3
    self.wave = 0
    self.steps = 0
    self.last_action = 0
    self.terminal = False
    self._start_wave()

  def _start_wave(self) -> None:
    head_count = self.wave + 1
    main_length = 10 - head_count
    self.chains = [self._make_chain(main_length, 0, 1)]
    for index in range(head_count - 1):
      self.chains.append(self._make_chain(1, index + 1, -1 if index % 2 else 1))
    self.spider: list[int] | None = [8, 9]
    self.flea: dict[str, object] | None = {"position": [0, int(self.random.randint(10))], "health": 2}
    self.scorpion: list[int] | None = [3, 0] if self.wave >= 3 else None
    self.previous_insects: list[list[int]] = []
    self.wave_steps = 0

  @staticmethod
  def _make_chain(length: int, row: int, direction: int) -> dict[str, object]:
    start = 0 if direction > 0 else 9
    segments = [[row, (start - direction * index) % 10] for index in range(length)]
    return {"segments": segments, "direction": direction, "diving": 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()
    if action in (1, 2, 3, 4):
      row_delta, column_delta = {1: (0, -1), 2: (-1, 0), 3: (0, 1), 4: (1, 0)}[action]
      target = [self.player[0] + row_delta, self.player[1] + column_delta]
      if 7 <= target[0] <= 9 and 0 <= target[1] < 10:
        self.player = target
    elif action == 5 and self.shot is None:
      self.shot = [self.player[0] - 1, self.player[1]]

    self.previous_insects = self._insect_positions()
    self._move_centipedes()
    self._move_specials()
    if self.shot is not None:
      self.shot[0] -= 1
      if self.shot[0] < 0:
        self.shot = None
    reward = self._resolve_shot()
    reward += self._resolve_contacts()
    self.wave_steps += 1
    self.steps += 1
    if not self.chains:
      self.wave += 1
      if self.wave == 4:
        self.terminal = True
      else:
        self._start_wave()
    if self.steps >= self.horizon:
      self.terminal = True
    return reward, self.terminal

  def _move_centipedes(self) -> None:
    for chain in self.chains:
      segments = chain["segments"]
      previous = [segment.copy() for segment in segments]
      head = segments[0]
      if bool(chain["diving"]):
        head[0] = min(9, head[0] + 1)
        if head[0] >= 8:
          chain["diving"] = False
          chain["direction"] = -int(chain["direction"])
      else:
        target_column = head[1] + int(chain["direction"])
        target = (head[0], target_column)
        if target_column < 0 or target_column > 9 or target in self.mushrooms:
          mushroom = self.mushrooms.get(target)
          if mushroom is not None and bool(mushroom["poisoned"]):
            chain["diving"] = True
          head[0] = min(9, head[0] + 1)
          chain["direction"] = -int(chain["direction"])
        else:
          head[1] = target_column
      for index in range(1, len(segments)):
        segments[index][:] = previous[index - 1]

  def _move_specials(self) -> None:
    if self.spider is not None:
      self.spider[1] += -1 if self.wave_steps % 4 < 2 else 1
      self.spider[0] = int(np.clip(self.spider[0] + (-1 if self.wave_steps % 3 == 0 else 1), 7, 9))
      if self.spider[1] < 0 or self.spider[1] > 9:
        self.spider[1] %= 10
    if self.flea is not None:
      position = self.flea["position"]
      position[0] += 2 if int(self.flea["health"]) == 1 else 1
      if position[0] in (2, 4, 6) and tuple(position) not in self.mushrooms:
        self.mushrooms[tuple(position)] = {"health": 3, "poisoned": False}
      if position[0] > 9:
        self.flea = None
    if self.scorpion is not None:
      self.scorpion[1] += 1
      position = tuple(self.scorpion)
      if position in self.mushrooms:
        self.mushrooms[position]["poisoned"] = True
      if self.scorpion[1] > 9:
        self.scorpion = None

  def _resolve_shot(self) -> float:
    if self.shot is None:
      return 0.0
    for chain in self.chains.copy():
      segments = chain["segments"]
      hit_index = next((index for index, segment in enumerate(segments) if segment == self.shot), None)
      if hit_index is None:
        continue
      position = tuple(segments[hit_index])
      reward = 100.0 if hit_index == 0 else 10.0
      before = segments[:hit_index]
      after = segments[hit_index + 1:]
      self.chains.remove(chain)
      if before:
        self.chains.append({"segments": before, "direction": chain["direction"], "diving": chain["diving"]})
      if after:
        self.chains.append({"segments": after, "direction": -int(chain["direction"]), "diving": False})
      self.mushrooms.setdefault(position, {"health": 3, "poisoned": False})
      self.shot = None
      return reward
    if self.spider == self.shot:
      distance = abs(self.spider[0] - self.player[0]) + abs(self.spider[1] - self.player[1])
      self.spider = None
      self.shot = None
      return 900.0 if distance <= 2 else 600.0 if distance <= 4 else 300.0
    if self.flea is not None and self.flea["position"] == self.shot:
      self.flea["health"] = int(self.flea["health"]) - 1
      self.shot = None
      if int(self.flea["health"]) == 0:
        self.flea = None
        return 200.0
      return 0.0
    if self.scorpion == self.shot:
      self.scorpion = None
      self.shot = None
      for mushroom in self.mushrooms.values():
        mushroom["poisoned"] = False
      return 1_000.0
    shot_position = tuple(self.shot)
    mushroom = self.mushrooms.get(shot_position)
    if mushroom is not None:
      mushroom["health"] = int(mushroom["health"]) - 1
      self.shot = None
      if int(mushroom["health"]) == 0:
        del self.mushrooms[shot_position]
        return 1.0
    return 0.0

  def _resolve_contacts(self) -> float:
    hazards = self._insect_positions()
    if self.player not in hazards:
      return 0.0
    bonus = float((len(self.mushrooms) // 2) * 5)
    self.lives -= 1
    self.player = [9, 5]
    self.previous_player = self.player.copy()
    self.shot = None
    for mushroom in self.mushrooms.values():
      mushroom["poisoned"] = False
      mushroom["health"] = 3
    if self.lives <= 0:
      self.terminal = True
    return bonus

  def _insect_positions(self) -> list[list[int]]:
    positions = [segment.copy() for chain in self.chains for segment in chain["segments"]]
    if self.spider is not None:
      positions.append(self.spider.copy())
    if self.flea is not None:
      positions.append(list(self.flea["position"]))
    if self.scorpion is not None:
      positions.append(self.scorpion.copy())
    return positions

  def state(self) -> np.ndarray:
    state = np.zeros((10, 10, 6), dtype=bool)
    state[*self.player, 0] = True
    for chain in self.chains:
      for index, segment in enumerate(chain["segments"]):
        state[*segment, 1] = True
        state[*segment, 2] = True
        if index == 0:
          state[segment[0], segment[1], 5] = True
    for position in (self.spider, None if self.flea is None else self.flea["position"], self.scorpion):
      if position is not None:
        state[*position, 1] = True
        state[*position, 2] = True
    for position, mushroom in self.mushrooms.items():
      state[*position, 2] = True
      state[*position, 5] = True
      if bool(mushroom["poisoned"]):
        state[*position, 1] = True
    if self.shot is not None:
      state[*self.shot, 3] = True
    state[*self.previous_player, 4] = True
    for position in self.previous_insects:
      if 0 <= position[0] < 10 and 0 <= position[1] < 10:
        state[*position, 4] = True
    state[9, : self.lives, 5] = True
    state[8, : self.wave + 1, 5] = True
    return state