from dataclasses import dataclass

import numpy as np


HORIZON = 400
GROUND = 32
UNIT = 4
SPAWN_INTERVAL = 5
MAX_BALLS = (HORIZON + SPAWN_INTERVAL - 1) // SPAWN_INTERVAL


@dataclass
class Ball:
  x: int
  y: int
  vx: int
  vy: int = 0


class BallsBombsEnvironment:
  score_cap = MAX_BALLS * (MAX_BALLS + 1) // 2

  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.scroll = 0
    self.player = 2
    self.next_bomb = 6
    self.bomb: int | None = None
    self.armed = False
    self.blast: tuple[int, int] | None = None
    self.multiplier = 1
    self.balls: list[Ball] = []
    self.terminal = False

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

  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
    self.last_action = action
    self.steps += 1
    if action == 5:
      self.player += 1
    self.scroll = max(0, self.player - 4)
    if not self.armed and self.bomb is None and self.player >= self.next_bomb:
      self.bomb = self.scroll + 9
    if self.bomb == self.player:
      self.armed = True
      self.bomb = None
      self.next_bomb = self.player + int(self.random.integers(9, 13))
    if self.blast is not None:
      center, radius = self.blast
      self.blast = (center, radius + 1) if radius < 6 else None
      if self.blast is None:
        self.multiplier = 1
    if self.steps % SPAWN_INTERVAL == 1:
      from_left = self.random.random() < 0.1
      self.balls.append(Ball(self.scroll + (0 if from_left else 9),
                             int(self.random.integers(5, 17)), 1 if from_left else -1))
    reward = 0
    survivors = []
    for ball in self.balls:
      ball.vy += 1
      ball.y += ball.vy
      if ball.y >= GROUND:
        ball.y = GROUND
        ball.vy = -ball.vy
      if self.steps % 2 == 0:
        ball.x += ball.vx
      if ball.x <= self.scroll and ball.vx < 0:
        ball.vx = 2
      elif ball.x >= self.scroll + 9 and ball.vx > 0:
        ball.vx = -1
      if self._in_blast(ball.y // UNIT, ball.x):
        reward += self.multiplier
        self.multiplier += 1
      elif ball.x == self.player and ball.y // UNIT == GROUND // UNIT:
        if self.armed:
          self.armed = False
          self.blast = self.player, 1
        else:
          self.terminal = True
      elif ball.x >= self.scroll - 2:
        survivors.append(ball)
    self.balls = survivors
    self.terminal |= self.steps >= self.horizon
    return float(reward), self.terminal

  def _in_blast(self, row: int, x: int) -> bool:
    if self.blast is None:
      return False
    center, radius = self.blast
    distance_squared = (x - center) ** 2 + (GROUND // UNIT - row) ** 2
    return (radius - 0.75) ** 2 <= distance_squared <= (radius + 0.75) ** 2

  def state(self) -> np.ndarray:
    state = np.zeros((10, 10, 6), dtype=bool)
    state[GROUND // UNIT, self.player - self.scroll, 0] = True
    for ball in self.balls:
      column = ball.x - self.scroll
      if 0 <= column < 10:
        row = max(0, ball.y // UNIT)
        state[row, column, 1] = True
        state[row, column, 4] |= ball.vy < 0
    if self.bomb is not None and 0 <= self.bomb - self.scroll < 10:
      state[GROUND // UNIT, self.bomb - self.scroll, 2] = True
    if self.blast is not None:
      for row in range(9):
        for column in range(10):
          state[row, column, 3] = self._in_blast(row, column + self.scroll)
    values = (self.steps, self.multiplier, int(self.armed), self.player,
              self.next_bomb, self.last_action, 0 if self.blast is None else self.blast[1])
    for row, value in enumerate(values):
      for bit in range(9):
        state[row, bit, 5] = bool(value & (1 << bit))
    return state