import Utility from "../js/Utility.js"
import { expect, test } from "./fixtures/test.js"

test.describe.configure({ mode: "parallel" })

test("clamp method test", () => {
    expect(Utility.clamp(5, 1, 11)).toBe(5)
    expect(Utility.clamp(5, 1, 6)).toBe(5)
    expect(Utility.clamp(5, 1, 5)).toBe(5)
    expect(Utility.clamp(5, 1, 4)).toBe(4)
    expect(Utility.clamp(5, 1, 3)).toBe(3)
    expect(Utility.clamp(-4, -3)).toBe(-3)
    expect(Utility.clamp(-4, -3, -1)).toBe(-3)
    expect(Utility.clamp(-1, -3, -2)).toBe(-2)
    expect(Utility.clamp(12, 11, 30)).toBe(12)
    expect(Utility.clamp(12, 12, 30)).toBe(12)
    expect(Utility.clamp(12, 13, 30)).toBe(13)
})

test("minDecimals method test", () => {
    expect(Utility.minDecimals(3.1, 3)).toBe("3.100")
    expect(Utility.minDecimals(-100, 2)).toBe("-100.00")
    expect(Utility.minDecimals(0.43, 0)).toBe("0.43")
    expect(Utility.minDecimals(0.43, 1)).toBe("0.43")
    expect(Utility.minDecimals(0.43, 2)).toBe("0.43")
    expect(Utility.minDecimals(0.43, 3)).toBe("0.430")
    expect(Utility.minDecimals(-2, 0)).toBe("-2")
})

test("roundDecimals method test", () => {
    expect(Utility.roundDecimals(8.543943, 0)).toBeCloseTo(9, 6)
    expect(Utility.roundDecimals(8.543943, 1)).toBeCloseTo(8.5, 6)
    expect(Utility.roundDecimals(8.543943, 2)).toBeCloseTo(8.54, 6)
    expect(Utility.roundDecimals(8.543943, 3)).toBeCloseTo(8.544, 6)
    expect(Utility.roundDecimals(-2.192837, 0)).toBeCloseTo(-2, 6)
    expect(Utility.roundDecimals(-2.192837, 1)).toBeCloseTo(-2.2, 6)
    expect(Utility.roundDecimals(-2.192837, 2)).toBeCloseTo(-2.19, 6)
    expect(Utility.roundDecimals(-2.192837, 3)).toBeCloseTo(-2.193, 6)
    expect(Utility.roundDecimals(-2.192837, 4)).toBeCloseTo(-2.1928, 6)
    expect(Utility.roundDecimals(-2.192837, 5)).toBeCloseTo(-2.19284, 6)
    expect(Utility.roundDecimals(-2.192837, 6)).toBeCloseTo(-2.192837, 6)
    expect(Utility.roundDecimals(-2.192837, 7)).toBeCloseTo(-2.192837, 6)
    expect(Utility.roundDecimals(-2.192837, 8)).toBeCloseTo(-2.192837, 6)
})

test("approximatelyEqual method test", () => {
    expect(Utility.approximatelyEqual(0.2 + 0.1, 0.3)).toBeTruthy()
    expect(Utility.approximatelyEqual(-0.2 - 0.1, -0.3)).toBeTruthy()
    expect(Utility.approximatelyEqual(0.1000001, 0.1)).toBeFalsy()
    expect(Utility.approximatelyEqual(40.1 + 0.2, 40.3)).toBeTruthy()
    expect(Utility.approximatelyEqual(2, 3)).toBeFalsy()
})

test("mergeArrays method test", () => {
    expect(Utility.mergeArrays(
        [],
        []
    )).toStrictEqual(
        []
    )
    expect(Utility.mergeArrays(
        ["alpba", "beta"],
        []
    )).toStrictEqual(
        ["alpba", "beta"]
    )
    expect(Utility.mergeArrays(
        [],
        ["alpba", "beta"]
    )).toStrictEqual(
        ["alpba", "beta"]
    )
    expect(Utility.mergeArrays(
        [1, 3, 5, 7, 9],
        [1, 2, 3, 4, 5]
    )).toStrictEqual(
        [1, 2, 3, 4, 5, 7, 9]
    )
    expect(Utility.mergeArrays(
        [6, 7, 8],
        [1, 2, 3]
    )).toStrictEqual(
        [6, 7, 8, 1, 2, 3]
    )
    expect(Utility.mergeArrays(
        ["e", "f", "g", "h"],
        ["a", "b", "c", "d"]
    )).toStrictEqual(
        ["e", "f", "g", "h", "a", "b", "c", "d"]
    )
    expect(Utility.mergeArrays(
        ["e", "f", "g", "h"],
        ["a", "b", "c", "d", "e"]
    )).toStrictEqual(
        ["a", "b", "c", "d", "e", "f", "g", "h"]
    )
    expect(Utility.mergeArrays(
        ["d", "e", "f", "g", "h"],
        ["a", "b", "c", "d"]
    )).toStrictEqual(
        ["a", "b", "c", "d", "e", "f", "g", "h"]
    )
    expect(Utility.mergeArrays(
        [2, 4, 6, 8],
        [6, 4, 2]
    )).toStrictEqual(
        [2, 4, 6, 8]
    )
    expect(Utility.mergeArrays(
        [2, 4, 6, 8],
        [4, 5, 6, 8, 1, 2]
    )).toStrictEqual(
        [2, 4, 5, 6, 8, 1]
    )
    expect(Utility.mergeArrays(
        [[0, ' '], [1, 'A'], [2, 'A'], [3, 'C']],
        [[2, 'B'], [3, 'C'], [4, 'D'], [5, 'E']],
        (l, r) => l[0] == r[0]
    )).toEqual(
        [[0, ' '], [1, 'A'], [2, 'A'], [3, 'C'], [4, 'D'], [5, 'E']]
    )
    expect(Utility.mergeArrays(
        [
            { id: 3, b: 1, a: 3 },
            { id: 7, b: 2, a: 9 },
            { id: 4, b: -6, a: 12 },
            { id: 9, b: 6, a: 20 },
            { id: 6, b: 1, a: 26 },
        ],
        [
            { id: 4, b: -6, a: 12 },
            { id: 6, b: 41, a: 76 },
            { id: 3, b: 5, a: 31 },
            { id: 13, b: 1, a: 22 },
            { id: 9, b: 55, a: 39 },
        ],
        (l, r) => l.id == r.id
    )).toEqual(
        [
            { id: 3, b: 1, a: 3 },
            { id: 7, b: 2, a: 9 },
            { id: 4, b: -6, a: 12 },
            { id: 9, b: 6, a: 20 },
            { id: 6, b: 1, a: 26 },
            { id: 13, b: 1, a: 22 },
        ]
    )
})

test("capitalFirstLetter method test", () => {
    expect(Utility.capitalFirstLetter("")).toBe("")
    expect(Utility.capitalFirstLetter("hello world")).toBe("Hello world")
})

test("range method test", () => {
    expect(Utility.range()).toStrictEqual([])
    expect(Utility.range(5, 5)).toStrictEqual([])
    expect(Utility.range(5, 6)).toStrictEqual([5])
    expect(Utility.range(1, 10, 3)).toStrictEqual([1, 4, 7])
    expect(Utility.range(0, -3)).toStrictEqual([0, -1, -2])
    expect(Utility.range(7, -7, -4)).toStrictEqual([7, 3, -1, -5])
})

test("String escaping methods test", () => {
    expect(Utility.escapeString("")).toBe("")
    expect(Utility.unescapeString("")).toBe("")

    expect(Utility.escapeString('"')).toBe('\\"')
    expect(Utility.unescapeString('\\"')).toBe('"')

    expect(Utility.escapeString(String.raw`\"`)).toBe(String.raw`\\\"`)
    expect(Utility.unescapeString(String.raw`\"`)).toBe('"')

    expect(Utility.escapeString(String.raw`Hello \"World\"`)).toBe(String.raw`Hello \\\"World\\\"`)
    expect(Utility.unescapeString(String.raw`Hello \"World\"`)).toBe('Hello "World"')

    expect(Utility.escapeString(String.raw`Those "\\" are two backslash`))
        .toBe(String.raw`Those \"\\\\\" are two backslash`)
    expect(Utility.unescapeString(String.raw`Those "\\" are two backslash`))
        .toBe(String.raw`Those "\" are two backslash`)

    expect(Utility.escapeString(String.raw`Alpha\Beta`)).toBe(String.raw`Alpha\\Beta`)
    expect(Utility.unescapeString(String.raw`Alpha\Beta`)).toBe(String.raw`Alpha\Beta`)

    expect(Utility.escapeString(String.raw`Alpha\\Beta`)).toBe(String.raw`Alpha\\\\Beta`)
    expect(Utility.unescapeString(String.raw`Alpha\\Beta`)).toBe(String.raw`Alpha\Beta`)

    expect(Utility.escapeString(String.raw`Alpha\\\Beta`)).toBe(String.raw`Alpha\\\\\\Beta`)
    expect(Utility.unescapeString(String.raw`Alpha\\\Beta`)).toBe(String.raw`Alpha\\Beta`)

    expect(Utility.escapeString(String.raw`Alpha\\\\Beta`)).toBe(String.raw`Alpha\\\\\\\\Beta`)
    expect(Utility.unescapeString(String.raw`Alpha\\\\Beta`)).toBe(String.raw`Alpha\\Beta`)

    expect(Utility.escapeString(String.raw`Alpha\\\\\Beta`)).toBe(String.raw`Alpha\\\\\\\\\\Beta`)
    expect(Utility.unescapeString(String.raw`Alpha\\\\\Beta`)).toBe(String.raw`Alpha\\\Beta`)

    expect(Utility.escapeString(String.raw`Alpha\\\\\\Beta`)).toBe(String.raw`Alpha\\\\\\\\\\\\Beta`)
    expect(Utility.unescapeString(String.raw`Alpha\\\\\\Beta`)).toBe(String.raw`Alpha\\\Beta`)

    expect(Utility.escapeString(String.raw`Alpha \"Beta\"`)).toBe(String.raw`Alpha \\\"Beta\\\"`)
    expect(Utility.unescapeString(String.raw`Alpha \"Beta\"`)).toBe(String.raw`Alpha "Beta"`)

    expect(Utility.escapeString(String.raw`Alpha \\"Beta\\"`)).toBe(String.raw`Alpha \\\\\"Beta\\\\\"`)
    expect(Utility.unescapeString(String.raw`Alpha \\"Beta\\"`)).toBe(String.raw`Alpha \"Beta\"`)

    expect(Utility.escapeString('Alpha\nBravo\\Charlie\n"Delta"')).toBe(
        String.raw`Alpha\nBravo\\Charlie\n\"Delta\"`
    )
    expect(Utility.unescapeString(String.raw`Alpha\nBravo\\Charlie\n\"Delta\"`)).toBe(
        `Alpha\nBravo\\Charlie\n"Delta"`
    )
})