from dataclasses import dataclass
import math

import numpy as np


HORIZON = 400
FRAMES_PER_STEP = 4
PLAYER_X = 35
GROUND = 80
JUMP_DURATION = 30


@dataclass
class Enemy:
  x: float
  y: float
  size: float


class BladeDancerEnvironment:
  score_cap = 100

  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.jump_ticks = 0.0
    self.y = float(GROUND)
    self.angle = math.pi / 2
    self.length = 10.0
    self.multiplier = 1
    self.enemies: list[Enemy] = []
    self.platforms = [(0.0, 200.0)]

  @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
    pressed = self.pressed if self.random.random() < self.sticky_action_prob else action == 5
    if pressed and not self.pressed and not self.jump_ticks:
      self.jump_ticks = JUMP_DURATION
      self.multiplier = 1
    self.pressed = pressed
    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 _sword_vector(self) -> tuple[float, float]:
    return self.length * math.cos(self.angle), self.length * math.sin(self.angle)

  def _advance_frame(self) -> int:
    if self.jump_ticks:
      self.jump_ticks = max(0, self.jump_ticks - (0.5 if self.pressed else 1))
      progress = self.jump_ticks / JUMP_DURATION
      self.y = GROUND - math.sin(progress * math.pi) * 30
      self.angle = self.angle - 0.3 if self.jump_ticks else math.pi / 2
      self.length = 8 + (1 - progress) * 22 if self.jump_ticks else 10

    if not self.enemies or self.random.random() < 0.04:
      if len(self.enemies) == 32:
        self.enemies.pop(0)
      self.enemies.append(Enemy(205, self.random.uniform(30, 75), self.random.uniform(3, 6)))
    reward = 0
    survivors = []
    sword_x, sword_y = self._sword_vector()
    sword_radius = 2.5 if self.jump_ticks else 1
    for enemy in self.enemies:
      enemy.x -= 1
      dx, dy = enemy.x - PLAYER_X, enemy.y - (self.y - 4)
      fraction = min(1, max(0, (dx * sword_x + dy * sword_y) / self.length**2))
      distance = math.hypot(dx - fraction * sword_x, dy - fraction * sword_y)
      radius = enemy.size / 2
      if distance <= radius + sword_radius:
        reward += self.multiplier
        self.multiplier += 1
        continue
      if abs(dx) < 2 + radius and abs(enemy.y - self.y) < 4 + radius:
        self.terminal = True
      if enemy.x >= -10:
        survivors.append(enemy)
    self.enemies = survivors

    self.platforms = [(left - 1, right - 1) for left, right in self.platforms if right >= 1]
    end = self.platforms[-1][1]
    if end < 200:
      gap = self.random.uniform(15, 30) if self.random.random() < 0.32 else 0
      length = self.random.uniform(30, 100) if gap else self.random.uniform(50, 150)
      self.platforms.append((end + gap, end + gap + length))
    if not self.jump_ticks and not any(left <= PLAYER_X <= right for left, right in self.platforms):
      self.terminal = True
    return reward

  def state(self) -> np.ndarray:
    state = np.zeros((10, 10, 6), dtype=bool)
    row, column = int(self.y) // 10, PLAYER_X // 20
    state[row, column, 0] = True
    state[row, column, 4] = self.jump_ticks > 0
    sword_x, sword_y = self._sword_vector()
    for fraction in np.linspace(0, 1, 12):
      y = int(self.y - 4 + fraction * sword_y) // 10
      x = int(PLAYER_X + fraction * sword_x) // 20
      state[y, x, 1] = True
    for enemy in self.enemies:
      if 0 <= enemy.x < 200:
        state[int(enemy.y) // 10, int(enemy.x) // 20, 2] = True
    for column in range(10):
      x = 20 * column + PLAYER_X % 20
      state[8, column, 3] = any(left <= x <= right for left, right in self.platforms)
    state[9, 0, 5] = self.pressed
    for row, value in enumerate((int(self.jump_ticks * 2), self.multiplier, self.steps)):
      for bit in range(9):
        state[row, bit, 5] = bool(value & (1 << bit))
    return state