from dataclasses import dataclass

import numpy as np


HORIZON = 400
COLUMN = 5
PLAYER_ROW = 9
PHASE_LENGTH = 6


@dataclass
class Wall:
  row: int
  phase: int
  width: int
  period: int
  direction: int

  def blocks(self, column: int) -> bool:
    return (column - self.phase) % self.period < self.width


class BWallsEnvironment:
  score_cap = HORIZON * 2 ** (PLAYER_ROW - 1)

  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.wall_clock = self.last_action = self.travel = 0
    self.multiplier = 1
    self.shot: int | None = None
    self.terminal = False
    self.walls: list[Wall] = []
    self._spawn(3)
    self._spawn(0)

  def _spawn(self, row: int) -> None:
    width = int(self.random.integers(1, 3))
    period = width + int(self.random.integers(2, 5))
    self.walls.append(Wall(row, int(self.random.integers(period)), width, period,
                           int(self.random.choice((-1, 1)))))

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

  @property
  def stopped(self) -> bool:
    return self.wall_clock // PHASE_LENGTH % 2 == 1

  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 action == 5 and self.last_action != 5 and self.shot is None:
      self.shot = PLAYER_ROW
      self.multiplier = 1
    self.last_action = action
    self.steps += 1
    moving = not self.stopped
    if moving:
      for wall in self.walls:
        wall.phase = (wall.phase + wall.direction) % wall.period

    near_launch = self.shot is not None and self.shot >= 7
    if near_launch or self.steps % (5 if self.steps < 200 else 4) == 0:
      self.travel += 1
      for wall in self.walls:
        wall.row += 1
      if self.travel % 3 == 0:
        self._spawn(0)

    reward = 0
    if self.shot is not None:
      self.shot -= 1
      if self.shot < 0 or any(wall.row == self.shot and wall.blocks(COLUMN) for wall in self.walls):
        self.shot = None
      else:
        for wall in self.walls:
          if wall.row - 1 == self.shot:
            reward = self.multiplier
            self.multiplier *= 2
            self.walls.remove(wall)
            break
        if moving and self.shot < max((wall.row for wall in self.walls), default=-2) + 1:
          self.shot = None
    if self.shot is None:
      self.wall_clock += 1
    self.terminal = any(wall.row == PLAYER_ROW and wall.blocks(COLUMN) for wall in self.walls)
    self.walls = [wall for wall in self.walls if wall.row <= PLAYER_ROW]
    self.terminal |= self.steps >= self.horizon
    return float(reward), self.terminal

  def state(self) -> np.ndarray:
    state = np.zeros((10, 10, 6), dtype=bool)
    state[PLAYER_ROW, COLUMN, 0] = True
    if self.shot is not None:
      state[self.shot, COLUMN, 3] = True
    for wall in self.walls:
      for column in range(10):
        state[wall.row, column, 1] = wall.blocks(column)
        state[wall.row, column, 4] = (column - wall.phase - wall.direction) % wall.period < wall.width
      if wall.row > 0:
        state[wall.row - 1, COLUMN, 2] = True
    for row, value in enumerate((self.steps, self.wall_clock % (2 * PHASE_LENGTH),
                                 self.travel % 3, self.multiplier, self.last_action)):
      for bit in range(10):
        state[row, bit, 5] = bool(value & (1 << bit))
    return state