// Reference:
// - https://docs.deno.com/runtime/fundamentals/testing/

import {assert} from "jsr:@std/assert/assert";
import {assertEquals} from "jsr:@std/assert";

import {
    decodeBase64Url,
    encodeBase64Url,
    formatHumanTime,
    formatPercent,
    formatSize,
    formatSize2,
    getKeyRingPassword,
    isOn,
    joinPath,
    setKeyRingPassword,
    sleep,
} from "./deno-commons-mod.ts";

Deno.test("isOn", () => {
    assertEquals(false, isOn(undefined));
    assertEquals(false, isOn(""));
    assertEquals(true, isOn("true"));
    assertEquals(true, isOn("TRUE"));
    assertEquals(true, isOn("yes"));
    assertEquals(true, isOn("YES"));
    assertEquals(true, isOn("on"));
    assertEquals(true, isOn("ON"));
    assertEquals(true, isOn("1"));
});

Deno.test("formatHumanTime", () => {
    assertEquals("0ms", formatHumanTime(0));
    assertEquals("1ms", formatHumanTime(1));
    assertEquals("1s", formatHumanTime(1000));
    assertEquals("1s", formatHumanTime(1001));
    assertEquals("1m", formatHumanTime(60001));
    assertEquals("1m 1s", formatHumanTime(61001));
    assertEquals("1h", formatHumanTime(3600000));
    assertEquals("1h 1s", formatHumanTime(3601000));
    assertEquals("1h 1m 1s", formatHumanTime(3661000));
});

Deno.test("formatSize", () => {
    assertEquals("N/A", formatSize(-1));
    assertEquals("0B", formatSize(0));
    assertEquals("1B", formatSize(1));
    assertEquals("1KiB", formatSize(1024));
    assertEquals("1KiB 1B", formatSize(1024 + 1));
    assertEquals("1MiB 1KiB 1B", formatSize(1024 * 1024 + 1024 + 1));
    assertEquals(
        "1GiB 1MiB 1KiB 1B",
        formatSize(1024 * 1024 * 1024 + 1024 * 1024 + 1024 + 1),
    );
});

Deno.test("formatSize2", () => {
    assertEquals("N/A", formatSize2(-1));
    assertEquals("0B", formatSize2(0));
    assertEquals("1B", formatSize2(1));
    assertEquals("1.00KiB", formatSize2(1024));
    assertEquals("10.00KiB", formatSize2(1024 * 10));
    assertEquals("1.00MiB", formatSize2(1024 * 1024));
});

Deno.test("formatPercent", () => {
    assertEquals("N/A", formatPercent(100, -1));
    assertEquals("N/A", formatPercent(100, 0));
    assertEquals("N/A", formatPercent(100, 0));
    assertEquals("10.00%", formatPercent(10, 100));
    assertEquals("11.00%", formatPercent(11, 100));
    assertEquals("1.10%", formatPercent(11, 1000));
    assertEquals("0.10%", formatPercent(1, 1000));
    assertEquals("0.00%", formatPercent(1, 100000));
    assertEquals("100.00%", formatPercent(100, 100));
});

Deno.test("sleep", async () => {
    const t1 = new Date().getTime();
    await sleep(1000);
    const t2 = new Date().getTime();
    assert(Math.abs(1000 - (t2 - t1)) < 20);
});

Deno.test("base64Url", () => {
    assertEquals(
        "_dxhVwI3qd9fMBlpEMmi6Q",
        encodeBase64Url(decodeBase64Url("_dxhVwI3qd9fMBlpEMmi6Q")),
    );
    assertEquals(
        "1dxJeD7erjAYUNEmdVNE8KdhpPZs0pAHtb-kbSqYIe5j039PkTHbrQYOEoeEWN4UsDERhnUg7mY",
        encodeBase64Url(
            decodeBase64Url(
                "1dxJeD7erjAYUNEmdVNE8KdhpPZs0pAHtb-kbSqYIe5j039PkTHbrQYOEoeEWN4UsDERhnUg7mY",
            ),
        ),
    );
});

Deno.test("test-key-ring-rs", () => {
    setKeyRingPassword("test-service", "test-user", "test-password");
    assertEquals(
        "test-password",
        getKeyRingPassword("test-service", "test-user"),
    );
});

Deno.test("join-path", () => {
    assertEquals("a/b", joinPath("a/", "/b"));
    assertEquals("a/b", joinPath("a/", "b"));
    assertEquals("a/b", joinPath("a", "/b"));
    assertEquals("a/b", joinPath("a", "b"));
    assertEquals("a/b/c", joinPath("a", "b", "/c"));
    assertEquals("a/b/c", joinPath("a", "b", "c"));
});