from dataclasses import dataclass
import math

import numpy as np


HORIZON = 400
FRAMES_PER_STEP = 4
SCROLL = 0.55
ROTATION = 0.022


@dataclass
class Wall:
  x: float
  gap_y: float
  height: float
  nub: bool
  passed: bool = False

  def blocked(self, y: float, margin: float = 0) -> bool:
    return (
      abs(y - self.gap_y) + margin > self.height / 2
      or self.nub and abs(y - 50) < 4 + margin
    )


@dataclass
class Beacon:
  x: float
  y: float


class BolaThreadEnvironment:
  score_cap = 150

  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.freeze = 0
    self.pressed = self.terminal = False
    self.angle, self.radius = 0.0, 20.0
    self.next_wall, self.next_beacon = 60.0, 100
    self.walls: list[Wall] = []
    self.beacons: list[Beacon] = []

  @property
  def balls(self) -> tuple[tuple[float, float], tuple[float, float]]:
    dx = math.cos(self.angle) * self.radius
    dy = math.sin(self.angle) * self.radius
    return (30 + dx, 50 + dy), (30 - dx, 50 - dy)

  @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:
      self.pressed = action == 5
    self.steps += 1
    reward = 0
    for _ in range(FRAMES_PER_STEP):
      reward += self._advance_frame()
      if self.terminal:
        break
    self.terminal |= self.steps >= self.horizon
    return float(reward), self.terminal

  def _advance_frame(self) -> int:
    if self.freeze:
      self.freeze -= 1
      return 0
    self.radius = max(6, self.radius - 0.6) if self.pressed else min(26, self.radius + 0.45)
    self.angle = (self.angle + ROTATION) % math.tau
    self.next_wall -= SCROLL
    self.next_beacon -= 1
    if self.next_wall < 0:
      arrival_angle = self.angle + ROTATION * (108 - 30) / SCROLL
      nub = self.random.random() < 0.36 and abs(math.sin(arrival_angle)) > 0.8
      gap_y = self.random.uniform(42, 58)
      height = self.random.uniform(42, 54) if nub else self.random.uniform(25, 40)
      self.walls.append(Wall(108, gap_y, height, nub))
      self.next_wall = self.random.uniform(65, 90)
    if self.next_beacon < 0:
      self.beacons.append(Beacon(108, self.random.uniform(20, 80)))
      self.next_beacon = int(self.random.integers(90, 151))

    reward = 0
    balls = self.balls
    for wall in self.walls:
      wall.x -= SCROLL
      if any(abs(x - wall.x) < 4 and wall.blocked(y, margin=2) for x, y in balls):
        self.terminal = True
        return reward
      if not wall.passed and wall.x < 30:
        wall.passed = True
        bonus = max(1, int((self.radius - 6) // 3))
        reward += bonus
        self.freeze = 2 + 2 * (bonus >= 3) + 2 * (bonus >= 5)
    self.walls = [wall for wall in self.walls if wall.x >= -5]
    survivors = []
    for beacon in self.beacons:
      beacon.x -= SCROLL
      if any(abs(x - beacon.x) < 4.5 and abs(y - beacon.y) < 4.5 for x, y in balls):
        reward += 8
      elif beacon.x >= -5:
        survivors.append(beacon)
    self.beacons = survivors
    return reward

  def state(self) -> np.ndarray:
    state = np.zeros((10, 10, 6), dtype=bool)
    state[5, 3, 0] = True
    for x, y in self.balls:
      state[int(y) // 10, int(x) // 10, 1] = True
    for wall in self.walls:
      if 0 <= wall.x < 100:
        column = int(wall.x) // 10
        for row in range(10):
          state[row, column, 2] |= abs(10 * row + 5 - wall.gap_y) > wall.height / 2
        state[4:6, column, 3] |= wall.nub
    for beacon in self.beacons:
      if 0 <= beacon.x < 100:
        state[int(beacon.y) // 10, int(beacon.x) // 10, 4] = True
    for row, value in enumerate((self.steps, round(self.radius * 10), round(self.angle * 80), self.freeze)):
      for bit in range(9):
        state[row, bit, 5] = bool(value & (1 << bit))
    state[9, 0, 5] = self.pressed
    return state