from dataclasses import dataclass

import numpy as np


HORIZON = 400
WAVE_DELAY = 8
MAX_WAVE = 4
PERIMETER = (
  tuple((9, x) for x in range(10))
  + tuple((y, 9) for y in range(8, -1, -1))
  + tuple((0, x) for x in range(8, -1, -1))
  + tuple((y, 0) for y in range(1, 9))
)


@dataclass
class Ball:
  row: int
  column: int
  dy: int
  dx: int
  size: int = 3
  immunity: int = 0


class BCannonEnvironment:
  score_cap = HORIZON // WAVE_DELAY * MAX_WAVE * 8 * 99

  def __init__(self, sticky_action_prob: float = 0.1, horizon: int = HORIZON):
    self.sticky_action_prob = sticky_action_prob
    self.horizon = min(horizon, HORIZON)
    self.seed(0)
    self.reset()

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

  def reset(self) -> None:
    self.steps = self.last_action = self.held = self.wave_size = self.ball_index = 0
    self.perimeter_index, self.direction = 5, 1
    self.wave_max, self.ball_period, self.wave_wait = 2, 3, WAVE_DELAY
    self.balls: list[Ball] = []
    self.rope: list[tuple[int, int]] = []
    self.rope_length = 0
    self.terminal = False

  @property
  def player(self) -> tuple[int, int]:
    return PERIMETER[self.perimeter_index]

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

  def _aim(self) -> tuple[int, int] | None:
    if not self.balls:
      return None
    row, column = self.player
    ball = min(self.balls, key=lambda item: (item.row - row) ** 2 + (item.column - column) ** 2)
    return max(1, min(8, ball.row + ball.dy)), max(1, min(8, ball.column + ball.dx))

  def _fire(self, target: tuple[int, int]) -> None:
    row, column = self.player
    dy, dx = target[0] - row, target[1] - column
    scale = max(abs(dy), abs(dx))
    self.rope = []
    for distance in range(1, 11):
      cell = row + round(dy * distance / scale), column + round(dx * distance / scale)
      if not all(0 < coordinate < 9 for coordinate in cell):
        break
      self.rope.append(cell)
    self.rope_length = 1

  def _spawn_wave(self) -> None:
    self.wave_size += 1
    if self.wave_size > self.wave_max:
      self.wave_size = 1
      self.wave_max = min(MAX_WAVE, self.wave_max + 1)
      self.ball_period = max(1, self.ball_period - 1)
    start = int(self.random.integers(1, 3))
    self.balls = [Ball(3, start + 2 * index, 1, 0) for index in range(self.wave_size)]
    self.ball_index = (self.ball_index + self.wave_size) % 100
    self.wave_wait = WAVE_DELAY

  def act(self, action: int) -> tuple[float, bool]:
    if self.terminal:
      return 0.0, True
    if self.random.random() < self.sticky_action_prob:
      action = self.last_action
    if action == 5 and self.last_action != 5:
      self.direction *= -1
    self.last_action = action
    self.steps += 1
    if action == 5:
      if self.balls:
        self.held += 1
        target = self._aim()
        if self.held == 3 and target is not None:
          self._fire(target)
    else:
      self.held = 0
      self.perimeter_index = (self.perimeter_index + self.direction) % len(PERIMETER)
    reward = self._advance_balls()
    if self.rope:
      self.rope_length += 1
      if self.rope_length > len(self.rope) + 1:
        self.rope.clear()
        self.rope_length = 0
    if not self.balls:
      self.wave_wait -= 1
      if self.wave_wait == 0:
        self._spawn_wave()
    self.terminal |= self.steps >= self.horizon
    return float(reward), self.terminal

  def _advance_balls(self) -> int:
    reward = 0
    remaining = []
    rope = set(self.rope[:self.rope_length])
    for ball in self.balls:
      if self.steps % self.ball_period == 0:
        if not 0 <= ball.row + ball.dy < 10:
          ball.dy *= -1
        if not 0 <= ball.column + ball.dx < 10:
          ball.dx *= -1
        ball.row += ball.dy
        ball.column += ball.dx
      ball.immunity = max(0, ball.immunity - 1)
      cell = ball.row, ball.column
      if cell in rope and not ball.immunity:
        if ball.size == 0:
          reward += self.ball_index
        else:
          remaining.extend(Ball(*cell, -ball.dy or 1, dx, ball.size - 1, 3) for dx in (-1, 1))
          self.ball_index = (self.ball_index + 2) % 100
      else:
        self.terminal |= cell == self.player
        remaining.append(ball)
    self.balls = remaining
    return reward

  def state(self) -> np.ndarray:
    state = np.zeros((10, 10, 6), dtype=bool)
    state[*self.player, 0] = True
    for ball in self.balls:
      state[ball.row, ball.column, 1] = True
      state[ball.row, ball.column, 2] |= ball.immunity > 0
    for cell in self.rope[:self.rope_length]:
      state[*cell, 3] = True
    target = self._aim()
    if target is not None:
      state[*target, 4] = True
    values = (self.steps, self.held, self.wave_size, self.wave_max, self.wave_wait,
              self.ball_period, self.ball_index, int(self.direction > 0), int(self.last_action == 5))
    for row, value in enumerate(values):
      for bit in range(9):
        state[row, bit, 5] = bool(value & (1 << bit))
    return state