import numpy as np


HORIZON = 320
SCHOOL_INTERVAL = 8
MAX_FISH = (HORIZON // SCHOOL_INTERVAL) * 3
ANCHOR = (3, 0)


class CastNEnvironment:
  score_cap = MAX_FISH * (MAX_FISH + 1) // 2

  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.mode = 0
    self.power = 0
    self.water = 50
    self.steps = 0
    self.last_action = 0
    self.lure = ANCHOR
    self.fish: set[tuple[int, int, bool]] = set()
    self.caught: list[bool] = []
    self.terminal = False

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

  def _line(self) -> set[tuple[int, int]]:
    row, column = self.lure
    if column == 0:
      return {ANCHOR}
    return {(round(ANCHOR[0] + (row - ANCHOR[0]) * x / column), x)
            for x in range(column + 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
    pressed = action == 5 and self.last_action != 5
    self.last_action = action
    self.steps += 1
    if self.mode == 0 and pressed:
      self.mode, self.power = 1, 1
    elif self.mode == 1:
      if action == 5 and self.power < 3:
        self.power += 1
      else:
        self.lure = (2, self.power * 3)
        self.mode = 2
    elif self.mode == 2 and pressed:
      self.mode = 3
    if self.mode == 2:
      row, column = self.lure
      self.lure = (min(9, row + 1), column)

    if self.steps % 2 == 0:
      surface = min(8, self.water // 10 + 1)
      self.fish = {(max(surface, row), column - 1, red)
                   for row, column, red in self.fish if column > 0}
    if self.steps % SCHOOL_INTERVAL == 0:
      red = self.steps % (SCHOOL_INTERVAL * 4) == 0
      depth = min(7, self.water // 10 + 1 + int(red))
      row = int(self.random.integers(depth, 8))
      self.fish.update((row + offset, 9, red) for offset in range(3))

    reward = 0
    if self.mode == 3:
      line = self._line()
      hooked = {fish for fish in self.fish if fish[:2] in line}
      self.fish.difference_update(hooked)
      self.caught.extend(red for _, _, red in sorted(hooked))
      row, column = self.lure
      if column <= 1:
        for index, red in enumerate(self.caught, 1):
          reward += -1 if red else index
          self.water = max(0, min(50, self.water + (-5 if red else 1)))
        self.caught.clear()
        self.lure, self.mode = ANCHOR, 0
      else:
        self.lure = (row + int(np.sign(ANCHOR[0] - row)), column - 1)
    if self.steps % 2 == 0:
      self.water = max(0, self.water - 1)
    self.terminal = self.steps >= self.horizon or (self.mode != 3 and self.water < 26)
    return float(reward), self.terminal

  def state(self) -> np.ndarray:
    state = np.zeros((10, 10, 6), dtype=bool)
    state[self.lure[0], self.lure[1], 0] = True
    for row, column, red in self.fish:
      state[row, column, 1 if red else 2] = True
    for row, column in self._line():
      state[row, column, 3] = True
    state[self.water // 10, :, 4] = True
    values = (self.mode, self.power, self.water, self.steps,
              len(self.caught), int(self.last_action == 5))
    for row, value in enumerate(values):
      for bit in range(9):
        state[row, bit, 5] = bool(value & (1 << bit))
    for index, red in enumerate(self.caught):
      state[6 + index // 10, index % 10, 5] = red
    return state