import { describe, expect, test } from "bun:test"
import {
  BackgammonEngine,
  BoardInit,
  defaultBoard,
  MatchState,
} from "../backgammonEngine"
import { parseMoveString } from "../backgammonMessage"
import { isExpectedError } from "../utils"

const ArrToInit = (arr: [number, number][]): [BoardInit, BoardInit] => {
  return [
    arr.filter(([, v]) => v > 0),
    arr.filter(([, v]) => v < 0).map(([i, v]) => [24 - i + 1, -v]),
  ]
}

const makeEngine = (
  config?: Partial<MatchState>,
  messages?: string[],
  init?: [BoardInit, BoardInit],
  reset?: [BoardInit, BoardInit]
) =>
  new BackgammonEngine(
    config || {},
    ["jack", "jill"],
    (msg) => messages?.push(msg),
    init,
    reset
  )

type RollMove = { rolls: number[]; move: string }
const runTestForConfig = ({
  config,
  valid,
  invalid,
  init,
  reset,
  m,
}: {
  config: Partial<MatchState>
  valid?: RollMove[]
  invalid?: RollMove[]
  init?: [BoardInit, BoardInit]
  reset?: [BoardInit, BoardInit]
  m?: string[]
}) => {
  for (const move of valid ?? []) {
    const moves = parseMoveString(move.move)
    if (isExpectedError(moves)) throw Error("Bad test move string" + move.move)
    const rollOrder = [move.rolls, [...move.rolls].reverse()]
    for (const rolls of rollOrder) {
      const e = makeEngine({ ...config, rolls }, m, init, reset)
      const r = e.tryApplyMove(moves) as any
      test(`valid: ${move.move} ${rolls}`, () => {
        expect(r.error).toBeUndefined()
      })
    }
  }

  for (const move of invalid ?? []) {
    const moves = parseMoveString(move.move)
    if (isExpectedError(moves)) throw Error("Bad test move string" + move.move)
    const rollOrder = [move.rolls, [...move.rolls].reverse()]
    for (const rolls of rollOrder) {
      const e = makeEngine({ ...config, rolls }, m, init, reset)
      const r = e.tryApplyMove(moves) as any
      test(`invalid: ${move.move} ${rolls} (${r?.error})`, () => {
        expect(r.error).toBeDefined()
      })
    }
  }
}

describe("tryApplyMove from starting", () => {
  runTestForConfig({
    config: {},
    valid: [
      { rolls: [6, 5], move: `24/18 18/13` },
      { rolls: [6, 5], move: `13/7 13/8` },
    ],
    invalid: [
      { rolls: [6, 5], move: `18/13 24/18` },
      { rolls: [6, 5], move: `23/17 17/12` },
      { rolls: [6, 5], move: `24/18 6/1` },
      { rolls: [6, 5], move: `13/7 13/8 13/8` },
    ],
  })
})

describe("jailFirst", () => {
  describe("single jail", () => {
    runTestForConfig({
      config: {},
      valid: [
        { rolls: [6, 6], move: `` },
        { rolls: [1, 1], move: `jail/24 24/23` },
        { rolls: [1, 1], move: `j/24 24/23` },
      ],
      invalid: [
        { rolls: [6, 6], move: `24/18 24/18` },
        { rolls: [1, 1], move: `24/23 24/23` },
        { rolls: [1, 1], move: `` },
      ],
      init: [
        [...defaultBoard, ["jail", 1]],
        [...defaultBoard, ["jail", 1]],
      ],
    })
  })

  describe("double jail", () => {
    runTestForConfig({
      config: {},
      init: [
        [...defaultBoard, ["jail", 2]],
        [...defaultBoard, ["jail", 2]],
      ],
      valid: [
        { rolls: [6, 6], move: `` },
        { rolls: [1, 1], move: `jail/24 jail/24` },
        { rolls: [1, 1, 1, 1], move: `jail/24 jail/24 24/23 24/23` },
        { rolls: [1, 1, 1, 1], move: `j/24 j/24 24/23 24/23` },
        { rolls: [2, 2], move: `jail/23 jail/23` },
      ],
      invalid: [
        { rolls: [1, 1, 1, 1], move: `j/24 j/24` },
        { rolls: [2, 2], move: `jail/24 jail/24` },
        { rolls: [2, 2], move: `jail/22 jail/22` },
        { rolls: [1, 1], move: `jail/24 24/23` },
        { rolls: [6, 6], move: `24/18 24/18` },
        { rolls: [1, 1], move: `24/23 24/23` },
      ],
    })
  })
})

describe("maximum travel", () => {
  runTestForConfig({
    config: {
      going: 0,
    },
    init: [
      [
        [4, 1],
        [24, 1],
      ],
      [
        [2, 2],
        [3, 2],
        [4, 2],
        [5, 2],
        [6, 2],
      ],
    ],
    valid: [
      { rolls: [6, 6], move: `24/18 18/12` },
      { rolls: [3, 2], move: `4/1` },
      { rolls: [5, 5], move: `` },
    ],
    invalid: [
      { rolls: [3, 2], move: `4/2` },
      { rolls: [6, 6], move: `24/18` },
    ],
  })
})

describe("maximum travel - backtracking", () => {
  runTestForConfig({
    config: {
      going: 0,
    },
    init: ArrToInit([
      [4, -2],
      [5, -2],
      [7, -2],
      [8, 1],

      [19, -2],
      [20, 1],
    ]),

    valid: [{ rolls: [1, 2], move: `20/18 18/17` }],
    invalid: [{ rolls: [1, 2], move: `8/6` }],
  })
})

describe("maximum travel - backtracking little", () => {
  runTestForConfig({
    config: {
      going: 0,
    },
    init: ArrToInit([
      [4, -2],
      [5, -2],
      [6, -2],
      [8, 1],

      [18, -2],
      [20, 1],
    ]),

    valid: [{ rolls: [1, 2], move: `20/19 19/17` }],
    invalid: [{ rolls: [1, 2], move: `8/7` }],
  })
})

describe("maximum travel - multiple paths", () => {
  runTestForConfig({
    config: {
      going: 0,
    },
    init: ArrToInit([
      [3, 1],
      [5, 1],
    ]),

    valid: [{ rolls: [4, 6], move: `5/f 3/f` }],
    invalid: [{ rolls: [4, 6], move: `5/1 3/f` }],
  })
})

describe("overshooting", () => {
  runTestForConfig({
    config: {
      going: 0,
    },
    init: ArrToInit([
      [5, 1],
      [7, 1],
    ]),

    valid: [{ rolls: [4, 6], move: `7/1 5/1` }],
    invalid: [{ rolls: [4, 6], move: `7/3 5/f` }],
  })
})

describe("hn test", () => {
  runTestForConfig({
    config: {
      going: 0,
    },
    init: ArrToInit([
      [1, 2],
      [2, 6],
      [3, 3],
      [5, -1],
      [6, 3],
      [7, -1],
      [9, 1],
      [19, -3],
      [20, -3],
      [21, -3],
      [22, -2],
      [23, -2],
    ]),
    valid: [
      { rolls: [4, 6], move: `9/5 6/f` },
      { rolls: [4, 6], move: `9/3 6/2` },
    ],
  })
})