import { expect, test } from "vitest"

import {
  arrayAdjust,
  arrayAll,
  arrayAny,
  arrayAppend,
  arrayConcat,
  arrayDrop,
  arrayDropLast,
  arrayEvery,
  arrayFilter,
  arrayFlat,
  arrayFlatMap,
  arrayForEach,
  arrayFromSpread,
  arrayHead,
  arrayIncludes,
  arrayIndexOf,
  arrayInit,
  arrayIntersection,
  arrayJoin,
  arrayLast,
  arrayLastIndexOf,
  arrayLength,
  arrayMap,
  arrayPartition,
  arrayPop,
  arrayPrepend,
  arrayPush,
  arrayReduce,
  arrayReduceLeft,
  arrayReduceRight,
  arrayReject,
  arrayRemove,
  arrayRemoveIndex,
  arrayReverse,
  arrayShift,
  arraySlice,
  arraySliceInit,
  arraySliceTail,
  arraySome,
  arraySort,
  arrayTail,
  arrayUnion,
  arrayUnique,
  arrayUniqueBy,
  arrayUnshift,
  arrayUpdate,
  shuffle,
} from "#Source/basic/index.ts"

test("arrayFromSpread converts iterables", () => {
  expect(arrayFromSpread(new Set([1, 2, 3]))).toEqual([1, 2, 3])
  expect(arrayFromSpread([])).toEqual([])
})

test("arrayLength returns array length", () => {
  expect(arrayLength(["a", "b", "c"])).toBe(3)
  expect(arrayLength([])).toBe(0)
})

test("arrayPop removes the last item", () => {
  expect(arrayPop([1, 2, 3])).toEqual([1, 2])
  expect(arrayPop(["only"])).toEqual([])
})

test("arrayPush appends an item", () => {
  expect(arrayPush(3, [1, 2])).toEqual([1, 2, 3])
  expect(arrayPush("a", [])).toEqual(["a"])
})

test("arrayAppend aliases arrayPush", () => {
  expect(arrayAppend(2, [1])).toEqual([1, 2])
  expect(arrayAppend("x", [])).toEqual(["x"])
})

test("arrayUnshift prepends an item", () => {
  expect(arrayUnshift(0, [1, 2])).toEqual([0, 1, 2])
  expect(arrayUnshift("a", [])).toEqual(["a"])
})

test("arrayPrepend aliases arrayUnshift", () => {
  expect(arrayPrepend("first", ["second"])).toEqual(["first", "second"])
  expect(arrayPrepend(true, [])).toEqual([true])
})

test("arrayShift removes the first item", () => {
  expect(arrayShift([1, 2, 3])).toEqual([2, 3])
  expect(arrayShift(["only"])).toEqual([])
})

test("arrayHead returns the first element", () => {
  expect(arrayHead([1, 2, 3])).toBe(1)
  expect(arrayHead([])).toBeUndefined()
})

test("arrayTail returns all but the first element", () => {
  expect(arrayTail([1, 2, 3])).toEqual([2, 3])
  expect(arrayTail(["only"])).toEqual([])
})

test("arrayInit returns all but the last element", () => {
  expect(arrayInit([1, 2, 3])).toEqual([1, 2])
  expect(arrayInit(["only"])).toEqual([])
})

test("arrayLast returns the last element", () => {
  expect(arrayLast([1, 2, 3])).toBe(3)
  expect(arrayLast([])).toBeUndefined()
})

test("arraySlice returns a portion of the array", () => {
  expect(arraySlice(1, 3, ["a", "b", "c", "d"])).toEqual(["b", "c"])
  expect(arraySlice(2, 2, [1, 2, 3])).toEqual([])
})

test("arraySliceTail returns a tail slice", () => {
  expect(arraySliceTail(2, [1, 2, 3, 4])).toEqual([3, 4])
  expect(arraySliceTail(1, ["only"])).toEqual([])
})

test("arrayDrop drops a rounded count", () => {
  expect(arrayDrop(2, [1, 2, 3, 4])).toEqual([3, 4])
  expect(arrayDrop(-2, [1, 2])).toEqual([])
})

test("arraySliceInit returns a head slice", () => {
  expect(arraySliceInit(2, [1, 2, 3, 4])).toEqual([1, 2])
  expect(arraySliceInit(0, [1, 2])).toEqual([])
})

test("arrayDropLast drops elements from the end", () => {
  expect(arrayDropLast(2, [1, 2, 3, 4])).toEqual([1, 2])
  expect(arrayDropLast(3, [1, 2])).toEqual([])
})

test("arrayRemove removes a range", () => {
  expect(arrayRemove(1, 3, ["a", "b", "c", "d"])).toEqual(["a", "d"])
  expect(arrayRemove(3, 1, [1, 2, 3, 4])).toEqual([1, 4])
})

test("arrayRemoveIndex removes a single index", () => {
  expect(arrayRemoveIndex(1, ["a", "b", "c"])).toEqual(["a", "c"])
  expect(arrayRemoveIndex(0, ["only"])).toEqual([])
})

test("arrayConcat appends arrays", () => {
  expect(arrayConcat([3, 4], [1, 2])).toEqual([1, 2, 3, 4])
  expect(arrayConcat([], ["a"])).toEqual(["a"])
})

test("arrayJoin joins elements", () => {
  expect(arrayJoin(",", ["a", "b", "c"])).toBe("a,b,c")
  expect(arrayJoin("-", [])).toBe("")
})

test("arrayIndexOf finds the first index", () => {
  expect(arrayIndexOf("b", ["a", "b", "c"])).toBe(1)
  expect(arrayIndexOf(9, [1, 2, 3])).toBe(-1)
})

test("arrayLastIndexOf finds the last index", () => {
  expect(arrayLastIndexOf("a", ["a", "b", "a"])).toBe(2)
  expect(arrayLastIndexOf(9, [1, 2, 3])).toBe(-1)
})

test("arrayIncludes checks membership", () => {
  expect(arrayIncludes(2, [1, 2, 3])).toBe(true)
  expect(arrayIncludes("x", ["a", "b"])).toBe(false)
})

test("arrayEvery verifies all items", () => {
  expect(arrayEvery((item) => item > 0, [1, 2, 3])).toBe(true)
  expect(arrayEvery((item) => item > 1, [1, 2, 3])).toBe(false)
})

test("arrayAll aliases arrayEvery", () => {
  expect(arrayAll((item) => item !== null, [1, 2])).toBe(true)
  expect(arrayAll((item) => item === 0, [0, 1])).toBe(false)
})

test("arraySome verifies at least one item", () => {
  expect(arraySome((item) => item > 2, [1, 2, 3])).toBe(true)
  expect(arraySome((item) => item < 0, [1, 2, 3])).toBe(false)
})

test("arrayAny aliases arraySome", () => {
  expect(arrayAny((item) => item === "b", ["a", "b"])).toBe(true)
  expect(arrayAny((item) => item === "x", ["a", "b"])).toBe(false)
})

test("arrayForEach applies the callback", () => {
  const target: number[] = []
  arrayForEach(
    (item) => {
      target.push(item * 2)
    },
    [1, 2, 3],
  )
  expect(target).toEqual([2, 4, 6])
})

test("arrayFilter keeps matching elements", () => {
  expect(arrayFilter((item) => item % 2 === 0, [1, 2, 3, 4])).toEqual([2, 4])
  expect(arrayFilter((item) => item > 0, [])).toEqual([])
})

test("arrayReject removes matching elements", () => {
  expect(arrayReject((item) => item % 2 === 0, [1, 2, 3, 4])).toEqual([1, 3])
  expect(arrayReject((item) => item === "b", ["a", "b"])).toEqual(["a"])
})

test("arrayPartition splits by predicate", () => {
  expect(arrayPartition((item) => item % 2 === 0, [1, 2, 3, 4])).toEqual([
    [2, 4],
    [1, 3],
  ])
  expect(arrayPartition((item) => item === "b", ["a"])).toEqual([[], ["a"]])
})

test("arrayMap transforms values", () => {
  expect(arrayMap((item) => item * 2, [1, 2, 3])).toEqual([2, 4, 6])
  expect(arrayMap((item) => item, [])).toEqual([])
})

test("arrayFlat flattens to specified depth", () => {
  expect(arrayFlat(1, [1, [2, 3], [4]])).toEqual([1, 2, 3, 4])
  expect(arrayFlat(2, [1, [[2]]])).toEqual([1, 2])
})

test("arrayFlatMap maps and flattens", () => {
  expect(arrayFlatMap((item) => [item, item], [1, 2])).toEqual([1, 1, 2, 2])
  expect(arrayFlatMap((item) => [item], [])).toEqual([])
})

test("arrayReduce aggregates left to right", () => {
  expect(arrayReduce((acc, item) => acc + item, 0, [1, 2, 3])).toBe(6)
  expect(arrayReduce((acc, item) => acc + item, "", ["a", "b", "c"])).toBe("abc")
})

test("arrayReduceLeft aliases arrayReduce", () => {
  expect(arrayReduceLeft((acc, item) => acc + item, 0, [1, 2, 3])).toBe(6)
  expect(arrayReduceLeft((acc, item) => acc + item, "", ["a", "b"])).toBe("ab")
})

test("arrayReduceRight aggregates right to left", () => {
  expect(arrayReduceRight((acc, item) => acc + item, "", ["a", "b", "c"])).toBe("cba")
  expect(arrayReduceRight((acc, item) => acc + item, 0, [1, 2, 3])).toBe(6)
})

test("arrayUnique removes duplicates", () => {
  expect(arrayUnique([1, 2, 1, 3])).toEqual([1, 2, 3])
  expect(arrayUnique(["a", "a"])).toEqual(["a"])
})

test("arrayUniqueBy removes duplicates by key", () => {
  const input = [{ id: 1 }, { id: 1 }, { id: 2 }]
  expect(arrayUniqueBy((item) => item.id, input)).toEqual([{ id: 1 }, { id: 2 }])
  expect(arrayUniqueBy((item) => item, [])).toEqual([])
})

test("arrayUnion combines unique values", () => {
  expect(arrayUnion([1, 2], [2, 3])).toEqual([1, 2, 3])
  expect(arrayUnion(["a"], [])).toEqual(["a"])
})

test("arrayIntersection finds common values", () => {
  expect(arrayIntersection([1, 2], [2, 3])).toEqual([2])
  expect(arrayIntersection(["a"], ["b"])).toEqual([])
})

test("arrayReverse returns reversed copy", () => {
  expect(arrayReverse([1, 2, 3])).toEqual([3, 2, 1])
  expect(arrayReverse([])).toEqual([])
})

test("arraySort sorts with compare function", () => {
  expect(arraySort((a, b) => a - b, [3, 1, 2])).toEqual([1, 2, 3])
  expect(arraySort((a, b) => a.localeCompare(b), ["b", "a"])).toEqual(["a", "b"])
})

test("shuffle preserves elements", () => {
  const input = [1, 2, 3, 4]
  const result = shuffle(input)
  expect(result).toHaveLength(4)
  expect(result.toSorted((a, b) => a - b)).toEqual(input.toSorted((a, b) => a - b))
})

test("arrayAdjust replaces a value via callback", () => {
  expect(arrayAdjust(1, (item) => item * 10, [1, 2, 3])).toEqual([1, 20, 3])
  expect(arrayAdjust(0, (item) => item, ["a"])).toEqual(["a"])
})

test("arrayUpdate replaces a value", () => {
  expect(arrayUpdate(1, 9, [1, 2, 3])).toEqual([1, 9, 3])
  expect(arrayUpdate(0, "x", ["a"])).toEqual(["x"])
})