// m03 rules: the pure game rules. Each function takes a state and returns a new one.
import { contains, dropLast } from './util.js'
import { pointEquals, point, delta, opposite } from './model.js'
/** @import { Point, Direction, GameState } from './types' */

/** The cell one step from `p` in direction `dir`. No wrapping: it may land outside the board.
 * @type {(p: Point, dir: Direction) => Point} */
export const move = (p, dir) => {
  const d = delta(dir)
  return point(p.x + d.x, p.y + d.y)
}

/** True if `p` lies on the board.
 * @type {(state: {width: number, height: number}, p: Point) => boolean} */
export const inBounds = (state, p) => p.x >= 0 && p.x < state.width && p.y >= 0 && p.y < state.height

/**
 * Ask to turn. We compare with `dir` (where the snake last moved), not `nextDir`:
 * otherwise Up-then-Left within one tick would turn a Right-moving snake back onto itself.
 * @type {(state: GameState, dir: Direction) => GameState}
 */
export const turn = (state, dir) =>
  state.status === 'Playing' && dir !== opposite(state.dir) ? { ...state, nextDir: dir } : state

/** One step of the game.
 * @type {(state: GameState) => GameState} */
export const advance = (state) => {
  if (state.status !== 'Playing') return state
  const d = state.nextDir
  const head = move(state.snake[0], d)
  const eating = state.apple !== null && pointEquals(head, state.apple)
  // When not eating, the tail leaves its cell this step, so the head may move into it.
  const body = eating ? state.snake : dropLast(state.snake)
  return !inBounds(state, head) || contains(body, head, pointEquals)
    ? { ...state, dir: d, status: 'GameOver' }
    : {
        ...state,
        snake: [head, ...body],
        dir: d,
        apple: eating ? null : state.apple,
        score: state.score + (eating ? 1 : 0),
      }
}