from dataclasses import dataclass
import math

import numpy as np


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


@dataclass(eq=False)
class Node:
  x: float
  y: float
  vx: float = 0
  vy: float = 0
  anchored: bool = True
  tethered: bool = False


@dataclass
class Link:
  a: Node
  b: Node
  length: float

  def near(self, x: float, y: float) -> bool:
    dx, dy = self.b.x - self.a.x, self.b.y - self.a.y
    px, py = x - self.a.x, y - self.a.y
    squared = dx * dx + dy * dy
    fraction = min(1, max(0, (px * dx + py * dy) / squared)) if squared else 0
    return math.hypot(px - fraction * dx, py - fraction * dy) <= 5


class CNodesEnvironment:
  score_cap = 500

  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.multiplier = 1
    self.next_node = self.boost = 0.0
    self.cursor = (3, 5)
    self.terminal = False
    self.nodes: list[Node] = []
    self.links: list[Link] = []

  @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:
      action = self.last_action
    if 1 <= action <= 4:
      dy, dx = DIRECTIONS[action - 1]
      row, col = self.cursor
      self.cursor = min(9, max(2, row + dy)), min(9, max(0, col + dx))
    if action == 5 and self.last_action != 5:
      row, col = self.cursor
      self.links = [link for link in self.links if not link.near(col * 10 + 5, row * 10 + 5)]
      self.multiplier = 1
      self.boost = 1
    self.last_action = action
    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:
    lowest = max((node.y for node in self.nodes), default=0)
    scroll = 0.03 + self.boost + max(0, 29 - lowest) * 0.1
    self.boost *= 0.7
    self.next_node -= scroll
    if self.next_node < 0:
      new = Node(self.random.uniform(10, 90), 0)
      for node in self.nodes:
        if node.anchored and abs(new.x - node.x) / 2 + abs(node.y) < 30 and self.random.random() < 0.7:
          self.links.append(Link(new, node, math.hypot(new.x - node.x, node.y)))
      self.nodes.append(new)
      self.next_node = 4
    for link in self.links:
      dx, dy = link.b.x - link.a.x, link.b.y - link.a.y
      distance = math.hypot(dx, dy)
      if distance:
        force = (distance - link.length) * 0.02 / distance
        link.a.vx += force * dx
        link.a.vy += force * dy
        link.b.vx -= force * dx
        link.b.vy -= force * dy
    for node in self.nodes:
      node.y += scroll
      node.anchored &= node.y <= 20
      if node.anchored:
        node.vx = node.vy = 0
      else:
        node.x += node.vx
        node.y += node.vy
        node.vx *= 0.95
        node.vy = (node.vy + 0.03) * 0.95
    self.links = [link for link in self.links if min(link.a.y, link.b.y) <= 100]
    self._update_tethers()
    reward = 0
    survivors = []
    for node in self.nodes:
      if node.tethered and node.y > 100:
        self.terminal = True
      if node.y > 140:
        reward += self.multiplier
        self.multiplier = min(64, self.multiplier * 2)
      else:
        survivors.append(node)
    self.nodes = survivors
    alive = set(survivors)
    self.links = [link for link in self.links if link.a in alive and link.b in alive]
    return reward

  def _update_tethers(self) -> None:
    connected = {node: [] for node in self.nodes}
    for link in self.links:
      connected[link.a].append(link.b)
      connected[link.b].append(link.a)
    pending = [node for node in self.nodes if node.anchored]
    reached = set(pending)
    while pending:
      for neighbor in connected[pending.pop()]:
        if neighbor not in reached:
          reached.add(neighbor)
          pending.append(neighbor)
    for node in self.nodes:
      node.tethered = node in reached and not node.anchored

  def state(self) -> np.ndarray:
    state = np.zeros((10, 10, 6), dtype=bool)
    for node in self.nodes:
      if 0 <= node.x < 100 and 0 <= node.y < 100:
        channel = 0 if node.anchored else 1 if node.tethered else 2
        state[int(node.y) // 10, int(node.x) // 10, channel] = True
    for link in self.links:
      for fraction in np.linspace(0, 1, 12):
        x = link.a.x + (link.b.x - link.a.x) * fraction
        y = link.a.y + (link.b.y - link.a.y) * fraction
        if 0 <= x < 100 and 0 <= y < 100:
          state[int(y) // 10, int(x) // 10, 3] = True
    row, col = self.cursor
    state[row, col, 4] = True
    for row, value in enumerate((self.steps, self.multiplier, self.last_action)):
      for bit in range(9):
        state[row, bit, 5] = bool(value & (1 << bit))
    return state