from collections import deque
from dataclasses import dataclass
import math

import numpy as np


HORIZON = 400
FRAMES_PER_STEP = 4
HEADINGS = ((1, 0), (0, 1), (-1, 0), (0, -1))


@dataclass
class Segment:
  x: float
  y: float
  dx: float
  dy: float
  born: int

  def overlaps(self, x: float, y: float) -> bool:
    if abs(x - self.x) > abs(self.dx) + 3 or abs(y - self.y) > abs(self.dy) + 3:
      return False
    length_squared = self.dx**2 + self.dy**2
    fraction = ((x - self.x) * self.dx + (y - self.y) * self.dy) / length_squared
    fraction = min(1, max(0, fraction))
    return math.hypot(x - self.x - fraction * self.dx, y - self.y - fraction * self.dy) < 3


class ChalkboardEnvironment:
  score_cap = HORIZON * FRAMES_PER_STEP * 3 // 10

  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.frame = self.heading = self.streak = 0
    self.turn_timer = 120
    self.pressed = self.terminal = False
    self.x = self.y = self.score_carry = 0.0
    self.write_x = self.write_y = 0.0
    self.energy = 60.0
    self.segments = deque(
      (Segment(70, y, 0, 10, -4) for y in range(-40, 40, 10)),
      maxlen=1000,
    )

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

  def _advance_frame(self, changed: bool) -> int:
    self.frame += 1
    self.turn_timer -= 1
    if not self.turn_timer:
      self.heading = (self.heading + 1) % 4
      self.turn_timer = int(self.random.integers(30, 150))
    dx, dy = HEADINGS[self.heading]
    self.x += 0.9 * dx
    self.y += 0.9 * dy
    self.streak = min(120, self.streak + 1)
    amount = 0.3 * (self.streak / 120)**1.5
    reward = 0
    if self.pressed:
      if changed:
        self.write_x, self.write_y = self.x, self.y
      if any(self.frame - line.born >= 4 and line.overlaps(self.x, self.y) for line in self.segments):
        self.energy -= 10
      else:
        self.energy += amount
        self.score_carry += amount
        reward = int(self.score_carry)
        self.score_carry -= reward
      dx, dy = self.x - self.write_x, self.y - self.write_y
      if dx * dx + dy * dy >= 4:
        self.segments.append(Segment(self.write_x, self.write_y, dx, dy, self.frame))
        self.write_x, self.write_y = self.x, self.y
    else:
      self.energy -= amount
    self.energy = min(100, max(0, self.energy))
    self.terminal = self.energy <= 0
    return reward

  def state(self) -> np.ndarray:
    state = np.zeros((10, 10, 6), dtype=bool)
    state[5, 5, 0] = True
    for line in self.segments:
      x, y = line.x - self.x + 50, line.y - self.y + 50
      if not (-12 <= x < 112 and -12 <= y < 112):
        continue
      channel = 2 if self.frame - line.born < 4 else 1
      for fraction in (0, 0.5, 1):
        px, py = x + line.dx * fraction, y + line.dy * fraction
        if 0 <= px < 100 and 0 <= py < 100:
          state[int(py) // 10, int(px) // 10, channel] = True
    dx, dy = HEADINGS[self.heading]
    state[5 + dy, 5 + dx, 3] = True
    if self.turn_timer <= 30:
      dx, dy = HEADINGS[(self.heading + 1) % 4]
      state[5 + dy, 5 + dx, 4] = True
    for row, value in enumerate((self.steps, round(self.energy), self.turn_timer, self.streak)):
      for bit in range(9):
        state[row, bit, 5] = bool(value & (1 << bit))
    state[9, 0, 5] = self.pressed
    return state