from dataclasses import dataclass
import math

import numpy as np


HORIZON = 400
FRAMES_PER_STEP = 4
HALF_PI = math.pi / 2


def wrap(angle: float) -> float:
  return (angle + math.pi) % math.tau - math.pi


@dataclass
class Wall:
  angle: float
  width: float
  y: float
  floating: bool
  bonus: bool

  def projection(self, player_angle: float, rear: bool = False) -> tuple[float, float]:
    relative = player_angle - self.angle + (math.pi if rear else 0)
    start = max(-HALF_PI, min(HALF_PI, wrap(relative - self.width / 2)))
    end = max(-HALF_PI, min(HALF_PI, wrap(relative + self.width / 2)))
    radius = 48 if self.floating else 44
    return 50 + math.sin(start) * radius, 50 + math.sin(end) * radius


class CTowerEnvironment:
  score_cap = 5000

  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 = 0
    self.pressed = self.terminal = False
    self.angle, self.y, self.speed = 0.0, 80.0, 3.0
    self.angular_velocity = -1.0
    self.direction = -1
    self.next_wall = 0.0
    self.next_bonus = self.multiplier = 1
    self.walls: list[Wall] = []

  @property
  def player_x(self) -> float:
    return 50 + 30 * self.angular_velocity

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

  def _advance_frame(self) -> float:
    self.speed += ((9 if self.pressed else 1) - self.speed) * 0.2
    self.angular_velocity += (self.direction - self.angular_velocity) * 0.2
    self.y = max(80, self.y - 0.01)
    self.angle = wrap(self.angle + self.angular_velocity * 0.05)
    scroll = self.speed * 0.3
    self.next_wall -= scroll
    if self.next_wall < 0:
      self.next_bonus -= 1
      bonus = self.next_bonus < 0
      if bonus:
        self.next_bonus = int(self.random.integers(9, 13))
      self.walls.append(Wall(self.random.uniform(0, math.tau),
                             self.random.uniform(math.pi / 4, HALF_PI),
                             -5, bonus or self.random.random() < 0.3, bonus))
      self.next_wall += self.random.uniform(30, 40)

    for wall in self.walls:
      wall.y += scroll
      left, right = wall.projection(self.angle)
      if left >= right or not (left - 3 < self.player_x < right + 3 and self.y - 3 < wall.y < self.y + 8):
        continue
      if wall.bonus:
        self.multiplier += 1
        wall.bonus = False
      elif not wall.floating:
        self.angle = wrap(wall.angle - self.direction * (wall.width / 2 + 0.7))
        self.direction *= -1
        self.y = min(99, wall.y + 6)
    self.walls = [wall for wall in self.walls if wall.y <= 105]
    self.terminal = self.y > 97
    return scroll * self.multiplier

  def state(self) -> np.ndarray:
    state = np.zeros((10, 10, 6), dtype=bool)
    state[int(self.y) // 10, int(self.player_x) // 10, 0] = True
    for wall in self.walls:
      if 0 <= wall.y < 100:
        row = int(wall.y) // 10
        for rear in (False, True):
          left, right = wall.projection(self.angle, rear)
          if left < right:
            channel = 4 if rear else 3 if wall.bonus else 2 if wall.floating else 1
            state[row, int(left) // 10:int(right) // 10 + 1, channel] = True
    for row, value in enumerate((self.steps, self.multiplier, round(self.speed * 10))):
      for bit in range(9):
        state[row, bit, 5] = bool(value & (1 << bit))
    state[9, :2, 5] = self.pressed, self.direction > 0
    return state