from dataclasses import dataclass

import numpy as np


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


@dataclass
class Mover:
  x: float
  y: float
  direction: int

  def move(self, speed: float) -> None:
    dx, dy = DIRECTIONS[self.direction]
    self.x += speed * dx
    self.y += speed * dy

  def inside(self, low: float, high: float) -> bool:
    return low <= self.x <= high and low <= self.y <= high

  def clamp(self) -> None:
    self.x = min(90, max(9, self.x))
    self.y = min(90, max(9, self.y))

  def touches(self, other: "Mover") -> bool:
    return abs(self.x - other.x) < 5 and abs(self.y - other.y) < 5


@dataclass
class Cate(Mover):
  entering: bool = True


class CatePEnvironment:
  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 = self.wave_count = self.wave_timer = 0
    self.multiplier = 1
    self.pressed = self.terminal = False
    self.player = Mover(50, 50, 0)
    self.shot: Mover | None = None
    self.entrance: Mover | None = None
    self.newest: Cate | None = None
    self.cates: list[Cate] = []

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

  def _advance_frame(self, tap: bool) -> int:
    player = self.player
    if tap or not player.inside(9, 90):
      if tap and self.shot is None:
        self.shot = Mover(player.x, player.y, player.direction)
        self.multiplier = 1
      player.clamp()
      player.direction = (player.direction + 2) % 8
    player.move(0.2)
    if self.shot is not None:
      if self.shot.inside(9, 91):
        self.shot.move(1.5)
      else:
        self.shot = None

    self._spawn()
    survivors = []
    reward = 0
    for cate in self.cates:
      cate.move(0.2)
      if cate.entering:
        cate.entering = not cate.inside(9, 90)
      elif not cate.inside(9, 90):
        corner = not 9 <= cate.x <= 90 and not 9 <= cate.y <= 90
        cate.direction = (cate.direction + (4 if corner else 3)) % 8
        cate.clamp()
      if self.shot is not None and cate.touches(self.shot):
        reward += self.multiplier
        self.multiplier += 1
        if self.newest is cate:
          self.newest = None
      else:
        self.terminal |= cate.touches(player)
        survivors.append(cate)
    self.cates = survivors
    return reward

  def _spawn(self) -> None:
    if self.wave_timer <= 0:
      direction = int(self.random.integers(4)) * 2
      offset = self.random.uniform(9, 90)
      x, y = ((-3, offset), (offset, -3), (103, offset), (offset, 103))[direction // 2]
      self.entrance = Mover(x, y, direction)
      self.wave_count = int(self.random.integers(5, 9))
      self.wave_timer = int(self.random.integers(60, 91))
    if self.wave_count == 0:
      self.wave_timer -= 1
    if self.newest is not None and self.newest.inside(3, 97):
      self.newest = None
    if self.wave_count and self.newest is None and self.entrance is not None:
      self.newest = Cate(self.entrance.x, self.entrance.y, self.entrance.direction)
      self.cates.append(self.newest)
      self.wave_count -= 1

  def state(self) -> np.ndarray:
    state = np.zeros((10, 10, 6), dtype=bool)
    for channel, movers in ((0, [self.player]), (1, self.cates), (2, [self.shot])):
      for mover in movers:
        if mover is not None and mover.inside(0, 99.999):
          row, col = int(mover.y) // 10, int(mover.x) // 10
          state[row, col, channel] = True
          if isinstance(mover, Cate):
            state[row, col, 3] |= mover.entering
    state[(0, 9), :, 4] = True
    state[:, (0, 9), 4] = True
    for row, value in enumerate((self.steps, self.player.direction, self.multiplier,
                                 self.shot.direction if self.shot is not None else 0)):
      for bit in range(9):
        state[row, bit, 5] = bool(value & (1 << bit))
    state[9, 0, 5] = self.pressed
    return state