import numpy as np


HORIZON = 400
FULL_TIME = 60
FEEDBACK_STEPS = 3
MAX_ANSWERS = (HORIZON + FEEDBACK_STEPS) // (FEEDBACK_STEPS + 1)


class BMathEnvironment:
  score_cap = 57 * MAX_ANSWERS * (MAX_ANSWERS + 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.steps = self.questions = self.feedback = self.last_action = 0
    self.time = FULL_TIME
    self.multiplier = 1
    self.correct = False
    self.selected = 0
    self.terminal = False
    self._question()

  def _question(self) -> None:
    self.operation = int(self.random.integers(min(4, 1 + self.questions // 5)))
    if self.operation < 2:
      total = int(self.random.integers(10, 100))
      part = int(self.random.integers(1, total))
      self.left, self.right, self.answer = (
        (part, total - part, total) if self.operation == 0 else (total, part, total - part)
      )
    else:
      factor = int(self.random.integers(2, 10))
      quotient = int(self.random.integers(2, 99 // factor + 1))
      product = factor * quotient
      self.left, self.right, self.answer = (
        (quotient, factor, product) if self.operation == 2 else (product, factor, quotient)
      )
    distractors = [value for value in range(max(1, self.answer - 7), min(99, self.answer + 7) + 1)
                   if value != self.answer]
    choices = self.random.choice(distractors, size=4, replace=False)
    self.options = self.random.permutation([self.answer, *choices]).tolist()

  @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
    reward = 0
    if self.feedback:
      self.feedback -= 1
      if not self.feedback:
        self._question()
    elif 1 <= action <= 5:
      reward = (57 * self.time * self.multiplier + FULL_TIME - 1) // FULL_TIME
      self.correct = self.options[action - 1] == self.answer
      self.selected = action
      if self.correct:
        self.time += 30
        if self.time >= FULL_TIME:
          self.multiplier += 1
      else:
        self.time -= 15
        self.multiplier = max(1, self.multiplier - 1)
      self.time = min(FULL_TIME, self.time)
      self.feedback = FEEDBACK_STEPS
      self.questions += 1
    self.time = max(0, self.time - 1)
    self.terminal = self.time == 0 or self.steps >= self.horizon
    return float(reward), self.terminal

  def state(self) -> np.ndarray:
    state = np.zeros((10, 10, 6), dtype=bool)
    state[self.operation, 0, 0] = True
    for row, value in enumerate((self.left, self.right, *self.options)):
      for bit in range(8):
        state[row, bit, 1] = bool(value & (1 << bit))
    if self.feedback:
      state[0, self.selected, 2] = True
      state[int(self.correct), 0, 3] = True
    for row, value in enumerate((self.time, self.multiplier, self.questions,
                                 self.feedback, self.steps, self.last_action)):
      for bit in range(9):
        state[row, bit, 5] = bool(value & (1 << bit))
    return state