from dataclasses import dataclass

import numpy as np


HORIZON = 300
RED_INTERVAL = 12
ORDINARY_INTERVAL = 4
MAX_RED = (HORIZON + RED_INTERVAL - 1) // RED_INTERVAL
MAX_BALLS = HORIZON // ORDINARY_INTERVAL + 10 * MAX_RED
MOVES = {1: (0, -1), 2: (-1, 0), 3: (0, 1), 4: (1, 0)}


@dataclass
class Ball:
  row: int
  column: int
  red: bool = False


class BBlastEnvironment:
  score_cap = MAX_BALLS * (MAX_BALLS + 1) // 2 + 10 * MAX_RED

  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.cursor = (5, 5)
    self.center = self.cursor
    self.steps = self.last_action = self.charge = self.cooldown = 0
    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.steps += 1
    self.cooldown = max(0, self.cooldown - 1)
    reward = 0
    if action == 5:
      if not self.charge:
        self.center = self.cursor
        self.charge = 1
      elif not self.cooldown or self.steps % 3 == 0:
        self.charge = min(12, self.charge + 1)
    else:
      if self.charge:
        reward += self._blast()
      if action in MOVES:
        dr, dc = MOVES[action]
        row, column = self.cursor
        self.cursor = max(0, min(9, row + dr)), max(0, min(9, column + dc))
    self.last_action = action
    if self.steps % RED_INTERVAL == 1:
      self.balls.append(Ball(1, int(self.random.integers(2, 8)), True))
    if self.steps % ORDINARY_INTERVAL == 0:
      self.balls.append(Ball(int(self.random.integers(2, 8)), int(self.random.integers(1, 9))))
    if self.steps % 2 == 0:
      reward += self._settle()
    self.terminal |= self.steps >= self.horizon
    return float(reward), self.terminal

  def _blast(self) -> int:
    row, column = self.center
    hit = [ball for ball in self.balls
           if (ball.row - row) ** 2 + (ball.column - column) ** 2 <= (self.charge / 2 + 0.5) ** 2]
    removed = {id(ball) for ball in hit}
    self.balls = [ball for ball in self.balls if id(ball) not in removed]
    for ball in hit:
      if ball.red:
        self.balls.extend(Ball(max(0, min(9, ball.row + dr)), max(0, min(9, ball.column + dc)))
                          for dr in (-1, 0, 1) for dc in (-1, 0, 1))
    self.charge = 0
    self.cooldown = 6
    return len(hit) * (len(hit) + 1) // 2

  def _settle(self) -> int:
    reward = 0
    occupied: set[tuple[int, int]] = set()
    for ball in sorted(self.balls, key=lambda item: -item.row):
      options = [(ball.row + 1, ball.column), (ball.row, ball.column),
                 (ball.row, ball.column - 1), (ball.row, ball.column + 1),
                 (ball.row - 1, ball.column)]
      for row, column in options:
        if 0 <= row < 10 and 0 <= column < 10 and (row, column) not in occupied:
          ball.row, ball.column = row, column
          occupied.add((row, column))
          break
      if ball.red and ball.row == 9:
        reward += 10
        ball.red = False
      if ball.row == 0:
        self.terminal = True
    return reward

  def state(self) -> np.ndarray:
    state = np.zeros((10, 10, 6), dtype=bool)
    state[*self.cursor, 0] = True
    for ball in self.balls:
      state[ball.row, ball.column, 1 if ball.red else 2] = True
    if self.charge:
      state[*self.center, 3] = True
      rows, columns = np.ogrid[:10, :10]
      state[:, :, 4] = ((rows - self.center[0]) ** 2 + (columns - self.center[1]) ** 2
                       <= (self.charge / 2 + 0.5) ** 2)
    for row, value in enumerate((self.steps, self.charge, self.cooldown, self.last_action)):
      for bit in range(9):
        state[row, bit, 5] = bool(value & (1 << bit))
    return state