import numpy as np


SIZE = 9
CENTER = SIZE // 2
EMPTY = -1
HORIZON = 400
GROWTH_INTERVAL = 30
SETTLE_DELAY = 15
DIRECTIONS = ((0, -1), (-1, 0), (1, 0), (0, 1))


class BreedCEnvironment:
  score_cap = 250

  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.growth_count = self.settle = self.clears = 0
    self.multiplier = 1
    self.timer = GROWTH_INTERVAL
    self.terminal = False
    self.cursor = CENTER, CENTER
    self.grid = np.full((SIZE, SIZE), EMPTY, dtype=np.int8)
    self.grid[CENTER, CENTER] = self.random.integers(4)
    self._grow()

  @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
    select = action == 5 and self.last_action != 5
    self.last_action = action
    self.steps += 1
    reward = 0
    if 1 <= action <= 4:
      dy, dx = DIRECTIONS[action - 1]
      y, x = self.cursor
      self.cursor = min(SIZE - 1, max(0, y + dy)), min(SIZE - 1, max(0, x + dx))
    if self.settle:
      self.settle -= 1
      if not self.settle:
        self._compact()
        self.clears += 1
        self.timer = GROWTH_INTERVAL
    else:
      if self.grid[CENTER, CENTER] == EMPTY:
        self.grid[CENTER, CENTER] = self.random.integers(4)
      if select:
        reward = self._erase()
      if not self.settle:
        self.timer -= 1
        if self.timer <= 0:
          self._grow()
    self.terminal = self.steps >= self.horizon or bool(np.all(self.grid != EMPTY))
    return float(reward), self.terminal

  def _erase(self) -> int:
    color = self.grid[self.cursor]
    group = set()
    if color != EMPTY:
      group.add(self.cursor)
      pending = [self.cursor]
      while pending:
        y, x = pending.pop()
        for dy, dx in DIRECTIONS:
          ny, nx = y + dy, x + dx
          neighbor = ny, nx
          if 0 <= ny < SIZE and 0 <= nx < SIZE and neighbor not in group and self.grid[neighbor] == color:
            group.add(neighbor)
            pending.append(neighbor)
    size = len(group)
    if size < 4:
      self._grow()
      self._grow()
      return -size
    for cell in group:
      self.grid[cell] = EMPTY
    reward = size * self.multiplier
    self.multiplier += 1
    self.settle = SETTLE_DELAY
    return reward

  def _grow(self) -> None:
    lines = self.grid if self.growth_count % 2 == 0 else self.grid.T
    old = lines.copy()
    lines[:, :CENTER - 1] = old[:, 1:CENTER]
    lines[:, CENTER + 2:] = old[:, CENTER + 1:-1]
    for line in lines:
      color = int(line[CENTER])
      if color != EMPTY:
        direction = int(self.random.choice((-1, 1)))
        new_color = (color + int(self.random.integers(3))) % 4
        line[CENTER - direction] = color
        line[CENTER] = line[CENTER + direction] = new_color
    self.growth_count += 1
    self.multiplier = 1
    self.timer = GROWTH_INTERVAL

  def _compact(self) -> None:
    axes = (self.grid, self.grid.T)
    if self.clears % 2:
      axes = axes[::-1]
    moved = True
    while moved:
      moved = False
      for lines in axes:
        for line in lines:
          for start, stop, step in ((CENTER, 0, -1), (CENTER, SIZE - 1, 1)):
            for index in range(start, stop, step):
              source = index + step
              if line[index] == EMPTY and line[source] != EMPTY:
                line[index], line[source] = line[source], EMPTY
                moved = True

  def state(self) -> np.ndarray:
    state = np.zeros((10, 10, 6), dtype=bool)
    for color in range(4):
      state[:SIZE, :SIZE, color] = self.grid == color
    state[*self.cursor, 4] = True
    for row, value in enumerate((self.steps, self.timer, self.settle, self.multiplier)):
      for bit in range(9):
        state[row, bit, 5] = bool(value & (1 << bit))
    state[9, 0, 5] = self.last_action == 5
    state[9, 1, 5] = self.growth_count % 2 == 1
    return state