import numpy as np


DELTAS = {1: (0, -1), 2: (-1, 0), 3: (0, 1), 4: (1, 0)}


class BoxingEnvironment:
  """Two-minute top-down bout with guarded jabs, power punches, and counter windows."""

  score_cap = 100.0

  def __init__(self, sticky_action_prob: float = 0.1, round_steps: int = 120):
    self.sticky_action_prob = sticky_action_prob
    self.round_steps = round_steps
    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 = [5, 2]
    self.opponent = [5, 7]
    self.previous_player = self.player.copy()
    self.previous_opponent = self.opponent.copy()
    self.player_score = 0
    self.opponent_score = 0
    self.player_recovery = 0
    self.opponent_recovery = 0
    self.player_punch: list[int] | None = None
    self.opponent_punch: list[int] | None = None
    self.steps = 0
    self.last_action = 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()
    self.previous_opponent = self.opponent.copy()
    self.player_punch = None
    self.opponent_punch = None
    reward = 0.0
    if action in DELTAS:
      self._move(self.player, self.opponent, action)
    elif action == 5 and self.player_recovery == 0:
      scored = self._punch(self.player, self.opponent, defender_is_player=False)
      reward = float(min(scored, 100 - self.player_score))
      self.player_score += int(reward)
      self.player_recovery = 2
    if self.player_score >= 100:
      self.player_score = 100
      self.terminal = True
      return reward, True

    if self.steps < 60 or self.steps % 2 == 0:
      self._opponent_action()
    self.player_recovery = max(0, self.player_recovery - 1)
    self.opponent_recovery = max(0, self.opponent_recovery - 1)
    self.steps += 1
    if self.opponent_score >= 100 or self.steps >= self.round_steps:
      self.opponent_score = min(100, self.opponent_score)
      self.terminal = True
    return reward, self.terminal

  @staticmethod
  def _move(boxer: list[int], other: list[int], action: int) -> None:
    row_delta, column_delta = DELTAS[action]
    target = [boxer[0] + row_delta, boxer[1] + column_delta]
    if 1 <= target[0] <= 8 and 1 <= target[1] <= 8 and target != other:
      boxer[:] = target

  def _punch(self, attacker: list[int], defender: list[int], defender_is_player: bool) -> int:
    row_distance = abs(attacker[0] - defender[0])
    column_distance = abs(attacker[1] - defender[1])
    distance = max(row_distance, column_distance)
    if distance > 2:
      return 0
    recovery = self.player_recovery if defender_is_player else self.opponent_recovery
    angled = row_distance > 0 and column_distance > 0
    if not angled and recovery == 0:
      return 0
    points = 2 if distance == 1 else 1
    punch_cell = [
      attacker[0] + int(np.sign(defender[0] - attacker[0])),
      attacker[1] + int(np.sign(defender[1] - attacker[1])),
    ]
    if defender_is_player:
      self.opponent_punch = punch_cell
    else:
      self.player_punch = punch_cell
    self._push(attacker, defender)
    return points

  @staticmethod
  def _push(attacker: list[int], defender: list[int]) -> None:
    row_delta = int(np.sign(defender[0] - attacker[0]))
    column_delta = int(np.sign(defender[1] - attacker[1]))
    target = [
      int(np.clip(defender[0] + row_delta, 1, 8)),
      int(np.clip(defender[1] + column_delta, 1, 8)),
    ]
    if target != attacker:
      defender[:] = target

  def _opponent_action(self) -> None:
    row_distance = abs(self.opponent[0] - self.player[0])
    column_distance = abs(self.opponent[1] - self.player[1])
    if max(row_distance, column_distance) <= 2 and self.opponent_recovery == 0:
      self.opponent_score += self._punch(self.opponent, self.player, defender_is_player=True)
      self.opponent_recovery = 2
      return
    candidates = []
    for action in DELTAS:
      row_delta, column_delta = DELTAS[action]
      target = [self.opponent[0] + row_delta, self.opponent[1] + column_delta]
      if not (1 <= target[0] <= 8 and 1 <= target[1] <= 8) or target == self.player:
        continue
      distance = max(abs(target[0] - self.player[0]), abs(target[1] - self.player[1]))
      angled_bonus = -1 if target[0] != self.player[0] and target[1] != self.player[1] else 0
      candidates.append((distance + angled_bonus, self.random.rand(), action))
    if candidates:
      self._move(self.opponent, self.player, min(candidates)[2])

  def state(self) -> np.ndarray:
    state = np.zeros((10, 10, 6), dtype=bool)
    state[*self.player, 0] = True
    state[*self.opponent, 1] = True
    state[*self.opponent, 2] = True
    if self.player_punch is not None:
      state[*self.player_punch, 3] = True
    state[*self.previous_player, 4] = True
    state[*self.previous_opponent, 4] = True
    state[9, : min(10, (self.player_score + 9) // 10), 5] = True
    state[8, : min(10, (self.opponent_score + 9) // 10), 5] = True
    remaining = max(0, self.round_steps - self.steps)
    state[7, : min(10, (remaining + 11) // 12), 5] = True
    state[6, : self.player_recovery, 5] = True
    return state