from dataclasses import dataclass

import numpy as np


HORIZON = 400
SPAWN_INTERVAL = 8
MAX_FISH = (HORIZON // SPAWN_INTERVAL) * 13
BIRD_ROW = 2
NORMAL, BIG, FAKE, EYE = range(4)
FLIGHT = (8, 7, 6, 5, 4, 3, 2, 1, 1, 2, 3, 4, 5, 6, 7, 8, 9)
FRAGMENTS = ((0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3),
             (1, 4), (1, 5), (2, 1), (2, 2), (2, 3), (2, 5))


@dataclass
class Fish:
  column: int
  kind: int = NORMAL
  age: int = 0
  row_offset: int = 0

  @property
  def row(self) -> int:
    return max(0, min(9, FLIGHT[self.age] + self.row_offset))


class BSFishEnvironment:
  score_cap = MAX_FISH * (1 + 5 * (MAX_FISH - 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.last_action = self.speed = 0
    self.multiplier = 1
    self.special_in = 3
    self.fish: list[Fish] = []
    self.terminal = False

  @property
  def bird_column(self) -> int:
    return 1 + self.speed // 2

  @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
    self.last_action = action
    self.steps += 1
    self.speed = min(6, self.speed + 1) if action == 5 else max(0, self.speed - 1)
    if self.steps % SPAWN_INTERVAL == 1:
      if self.special_in == 0:
        kind = int(self.random.choice((BIG, FAKE)))
        self.special_in = int(self.random.integers(3, 9))
      else:
        kind = NORMAL
        self.special_in -= 1
      self.fish.append(Fish(int(self.random.integers(7, 10)), kind))
    reward = 0
    remaining = []
    for fish in self.fish:
      fish.age += 1
      if self.speed >= 4 or self.steps % 3 == 0:
        fish.column -= 1
      if fish.age == len(FLIGHT) or fish.column < -1:
        if fish.kind != BIG:
          self.multiplier = max(1, self.multiplier - 1)
        continue
      if fish.kind == FAKE and fish.row <= 5:
        remaining.extend(Fish(fish.column + column - 2, EYE if (row, column) == (1, 2) else NORMAL,
                              fish.age, row - 1) for row, column in FRAGMENTS)
      elif fish.kind == BIG:
        if abs(fish.row - BIRD_ROW) <= 1 and abs(fish.column - self.bird_column) <= 1:
          self.terminal = True
        remaining.append(fish)
      elif fish.row == BIRD_ROW and fish.column == self.bird_column:
        reward += self.multiplier
        self.multiplier += 10 if fish.kind == EYE else 1
      else:
        remaining.append(fish)
    self.fish = 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)
    state[BIRD_ROW, self.bird_column, 0] = True
    for fish in self.fish:
      if 0 <= fish.column < 10:
        channel = (2, 1, 1, 3)[fish.kind]
        state[fish.row, fish.column, channel] = True
        next_row = FLIGHT[min(fish.age + 1, len(FLIGHT) - 1)] + fish.row_offset
        if 0 <= next_row < 10:
          state[next_row, fish.column, 4] = True
    for row, value in enumerate((self.steps, self.speed, self.multiplier, self.special_in, self.last_action)):
      for bit in range(13):
        index = row * 13 + bit
        state[index // 10, index % 10, 5] = bool(value & (1 << bit))
    return state