from math import ceil, cos, sin

import numpy as np


HORIZON = 400
SPAWN_INTERVAL = 6
FLOOR = 9
MIN_LENGTH = 20
MAX_LENGTH = 64


class BalanceEnvironment:
  score_cap = ((HORIZON + SPAWN_INTERVAL - 1) // SPAWN_INTERVAL) * 3 * MAX_LENGTH

  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 = 0
    self.base = self.cursor = 4.5
    self.velocity = self.angle = self.angular_velocity = self.wind = 0.0
    self.length = MIN_LENGTH
    self.coin_column = float(self.random.choice((2, 7)))
    self.coins: list[tuple[float, float, float]] = []
    self.terminal = False

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

  @property
  def tip(self) -> tuple[float, float]:
    return FLOOR - cos(self.angle) * self.length / 8, self.base + sin(self.angle) * self.length / 8

  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
    self.cursor = max(0.0, min(9.0, self.cursor + (1 if action == 3 else -1 if action == 1 else 0)))
    self.wind = 0.94 * (self.wind + float(self.random.uniform(-0.025, 0.025)))
    self.velocity = 0.90 * (self.velocity + 0.08 * (self.cursor - self.base) - self.wind)
    self.base += self.velocity
    self.angular_velocity = 0.88 * (self.angular_velocity - 0.16 * self.velocity
                                    + self.angle * self.length / 800)
    self.angle += self.angular_velocity
    row, column = self.tip
    shift = (4.5 - column) * 0.18
    self.base += shift
    self.cursor = max(0.0, min(9.0, self.cursor + shift))
    if row >= FLOOR - 0.25:
      self.length /= 2
      self.angular_velocity *= -0.5
      if self.length < MIN_LENGTH:
        self.terminal = True
        return 0.0, True
      self.angle /= 2
    if self.steps % SPAWN_INTERVAL == 1:
      self.coins.append((0.0, self.coin_column, float(self.random.uniform(-0.15, 0.15))))
      self.coin_column = (self.coin_column + shift + float(self.random.uniform(-0.6, 0.6))) % 10

    row, column = self.tip
    reward = 0
    remaining = []
    for y, x, drift in self.coins:
      y += 0.5
      drift = 0.96 * (drift + self.wind / 2)
      x += drift + shift
      tip_hit = abs(y - row) <= 0.45 and abs(x - column) <= 0.55
      fraction = (FLOOR - y) / max(0.01, FLOOR - row)
      shaft_x = self.base + (column - self.base) * fraction
      if tip_hit or (0 <= fraction <= 1 and abs(x - shaft_x) <= 0.45):
        for _ in range(3 if tip_hit else 1):
          reward += ceil(self.length)
          self.length = min(MAX_LENGTH, self.length + 1)
      elif y < FLOOR:
        remaining.append((y, x, drift))
    self.coins = remaining
    self.terminal = self.steps >= self.horizon
    return float(reward), self.terminal

  def state(self) -> np.ndarray:
    state = np.zeros((10, 10, 6), dtype=bool)
    row, column = self.tip
    state[min(9, max(0, round(row))), min(9, max(0, round(column))), 0] = True
    state[FLOOR, :, 1] = True
    for y, x, _ in self.coins:
      if 0 <= round(x) < 10:
        state[round(y), round(x), 2] = True
    for fraction in np.linspace(0, 1, 16):
      x = round(self.base + fraction * (column - self.base))
      y = round(FLOOR + fraction * (row - FLOOR))
      if 0 <= x < 10 and 0 <= y < 10:
        state[y, x, 3] = True
    state[FLOOR, round(self.cursor), 4] = True
    values = (self.steps, round(self.length * 4), round(self.angle * 64) + 256,
              round(self.angular_velocity * 128) + 256, round(self.velocity * 32) + 256,
              round(self.wind * 512) + 256, self.last_action)
    for row, value in enumerate(values):
      for bit in range(10):
        state[row, bit, 5] = bool(value & (1 << bit))
    return state