import kotlinx.serialization.ExperimentalSerializationApi
import kotlinx.serialization.json.Json
import moe.rosa.planterette.hakurei.*
import org.junit.jupiter.api.assertDoesNotThrow
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFailsWith
import kotlin.test.assertIs

class HakureiTest {
    companion object {
        val TEMPLATE_DATA = HakureiConfig(
            id = "org.chromium.Chromium",
            path = AbsolutePath("/run/current-system/sw/bin/chromium"),
            args = listOf(
                "chromium",
                "--ignore-gpu-blocklist",
                "--disable-smooth-scrolling",
                "--enable-features=UseOzonePlatform",
                "--ozone-platform=wayland"
            ),
            enablements = Enablements(
                wayland = true,
                dbus = true,
                pulse = true
            ),
            sessionBus = DBusConfig(
                see = null,
                talk = listOf(
                    "org.freedesktop.Notifications",
                    "org.freedesktop.FileManager1",
                    "org.freedesktop.ScreenSaver",
                    "org.freedesktop.secrets",
                    "org.kde.kwalletd5",
                    "org.kde.kwalletd6",
                    "org.gnome.SessionManager"
                ),
                own = listOf(
                    "org.chromium.Chromium.*",
                    "org.mpris.MediaPlayer2.org.chromium.Chromium.*",
                    "org.mpris.MediaPlayer2.chromium.*"
                ),
                call = mapOf(
                    "org.freedesktop.portal.*" to "*"
                ),
                broadcast = mapOf(
                    "org.freedesktop.portal.*" to "@/org/freedesktop/portal/*"
                ),
                filter = true
            ),
            systemBus = DBusConfig(
                see = null,
                talk = listOf(
                    "org.bluez",
                    "org.freedesktop.Avahi",
                    "org.freedesktop.UPower"
                ),
                own = null,
                call = null,
                broadcast = null,
                filter = true
            ),
            username = "chronos",
            shell = AbsolutePath("/run/current-system/sw/bin/zsh"),
            home = AbsolutePath("/data/data/org.chromium.Chromium"),
            extraPerms = listOf(
                ExtraPermsConfig(
                    ensure = true,
                    path = AbsolutePath("/var/lib/hakurei/u0"),
                    read = null,
                    write = null,
                    execute = true,
                ),
                ExtraPermsConfig(
                    ensure = null,
                    path = AbsolutePath("/var/lib/hakurei/u0/org.chromium.Chromium"),
                    read = true,
                    write = true,
                    execute = true,
                ),
            ),
            identity = 9,
            groups = listOf(
                "video",
                "dialout",
                "plugdev"
            ),
            container = ContainerConfig(
                hostname = "localhost",
                waitDelay = -1,
                seccompCompat = true,
                devel = true,
                userns = true,
                hostNet = true,
                hostAbstract = true,
                tty = true,
                multiarch = true,
                env = mapOf(
                    "GOOGLE_API_KEY" to "AIzaSyBHDrl33hwRp4rMQY0ziRbj8K9LPA6vUCY",
                    "GOOGLE_DEFAULT_CLIENT_ID" to "77185425430.apps.googleusercontent.com",
                    "GOOGLE_DEFAULT_CLIENT_SECRET" to "OTJgUOQcT7lO7GsGZq2G4IlT"
                ),
                mapRealUid = true,
                device = true,
                filesystem = listOf(
                    FSBind(
                        target = AbsolutePath("/"),
                        source = AbsolutePath("/var/lib/hakurei/base/org.debian"),
                        write = true,
                        special = true,
                    ),
                    FSBind(
                        target = AbsolutePath("/etc/"),
                        source = AbsolutePath("/etc/"),
                        special = true,
                    ),
                    FSEphemeral(
                        target = AbsolutePath("/tmp/"),
                        write = true,
                        perm = 493
                    ),
                    FSOverlay(
                        target = AbsolutePath("/nix/store"),
                        lower = listOf(
                            AbsolutePath("/mnt-root/nix/.ro-store")
                        ),
                        upper = AbsolutePath("/mnt-root/nix/.rw-store/upper"),
                        work = AbsolutePath("/mnt-root/nix/.rw-store/work")
                    ),
                    FSBind(
                        source = AbsolutePath("/nix/store")
                    ),
                    FSLink(
                        target = AbsolutePath("/run/current-system"),
                        linkname = "/run/current-system",
                        dereference = true
                    ),
                    FSLink(
                        target = AbsolutePath("/run/opengl-driver"),
                        linkname = "/run/opengl-driver",
                        dereference = true
                    ),
                    FSBind(
                        target = AbsolutePath("/data/data/org.chromium.Chromium"),
                        source = AbsolutePath("/var/lib/hakurei/u0/org.chromium.Chromium"),
                        write = true,
                        ensure = true,
                    ),
                    FSBind(
                        source = AbsolutePath("/dev/dri"),
                        device = true,
                        optional = true
                    )
                )
            )
        )
        val TEMPLATE_JSON = ProcessBuilder("hakurei", "template")
            .start()
            .inputStream
            .readAllBytes()
            .toString(Charsets.UTF_8)
        val format = Json {
            prettyPrint = true
            ignoreUnknownKeys = true
        }
    }

    @OptIn(ExperimentalSerializationApi::class)
    @Test
    fun deserializeTest() {

        println(TEMPLATE_JSON)
        val want = format.decodeFromString<HakureiConfig>(TEMPLATE_JSON)
        assertEquals(TEMPLATE_DATA, want)
    }
    @OptIn(ExperimentalSerializationApi::class)
    @Test
    fun serializeTest() {
        val encoded = format.encodeToString(TEMPLATE_DATA)
        val decoded = format.decodeFromString<HakureiConfig>(encoded)
        assertEquals(TEMPLATE_DATA, decoded)
    }
    @Test
    fun absolutePathTest() {
        assertDoesNotThrow {
            AbsolutePath("/test/absolutepath")
        }
        assertFailsWith(AbsolutePathException::class) {
            AbsolutePath("./../../../../")
        }
        assertEquals(AbsolutePath("/test/absolutepath"), AbsolutePath("/test/") + "absolutepath")
    }
    @Test
    fun extraPermsTest() {
        assertIs<String>(TEMPLATE_DATA.extraPerms.toString())
    }
}