"""Strip move-reasoning fields that can be rebuilt from the stored turn.

Snakes put values like ``turn``, ``health`` or ``head`` into their reasoning
payload although the same values are stored in the turn and snake rows. Such a
field is only removed when it equals the derived value, and a bitmask records
which fields were removed, so restoring is exact.
"""

DERIVED_KEYS = ("turn", "move", "head", "health", "length", "food_count", "board_size", "snakes")
MASK_KEY = "_derived"
_RAW_KEY = "_raw"

def derived_values(turn:int, move:str|None, you:dict|None, food:list, width:int|None, height:int|None, snake_count:int) -> dict:
  you = you or {}
  return {
    "turn": turn,
    "move": move,
    "head": you.get("head"),
    "health": you.get("health"),
    "length": you.get("length"),
    "food_count": len(food),
    "board_size": f"{width}x{height}",
    "snakes": snake_count,
  }

def _same(stored:object, derived:object) -> bool:
  # bool is an int subclass; never treat True == 1 as derivable.
  return type(stored) is type(derived) and stored == derived

def slim_thinking(thinking:object, derived:dict) -> object:
  if not isinstance(thinking, dict):
    return thinking
  if MASK_KEY in thinking:
    # A payload that already uses the marker key is stored verbatim.
    return {MASK_KEY: 0, _RAW_KEY: thinking}
  mask = 0
  slim = {}
  for key, value in thinking.items():
    if key in DERIVED_KEYS and _same(value, derived[key]):
      mask |= 1 << DERIVED_KEYS.index(key)
    else:
      slim[key] = value
  if mask:
    slim[MASK_KEY] = mask
  return slim

def restore_thinking(thinking:object, derived:dict) -> object:
  if not isinstance(thinking, dict) or MASK_KEY not in thinking:
    return thinking
  mask = int(thinking[MASK_KEY])
  if mask == 0 and _RAW_KEY in thinking:
    return thinking[_RAW_KEY]
  restored = {key: value for key, value in thinking.items() if key != MASK_KEY}
  for index, key in enumerate(DERIVED_KEYS):
    if mask & (1 << index):
      restored[key] = derived[key]
  return restored