Reverse-Engineering Cookies with Ktor

// Minimalistic document library only for the things I need
internal class Document(
    val url: String,
    val html: String
) {

    val body: Element
        get() = querySelector("body") ?: throw IllegalStateException("Document does not have a body element")

    val bodyElements: String
        get() = body.innerHTML
            .replace(Regex("<script\\b[^>]*>([\\s\\S]*?)</script>"), "")
            .replace(Regex("<style\\b[^>]*>([\\s\\S]*?)</style>"), "")

    val head: Element
        get() = querySelector("head") ?: throw IllegalStateException("Document does not have a head element")

}

// Performs a CSS Query Selection on the document
internal expect fun Document.querySelectorAll(selector: String): List<Element>
internal fun Document.querySelector(selector: String): Element? = querySelectorAll(selector).firstOrNull()
internal fun Document.getElementById(id: String): Element? = querySelector("#$id")
internal fun Document.getElementsByClassName(className: String): List<Element> = querySelectorAll(".$className")
internal fun Document.inputValue(name: String): String? {
    val input = querySelector("input[name=$name]") ?: return null
    return input["value"] ?: input["checked"]
}

// Minimilastic element library only for the things I needs
internal class Element(
    val tagName: String,
    val innerHTML: String,
    val textContent: String,
    val attributes: Map<String, String>,
    val children: List<Element>
) {
    operator fun get(attribute: String): String? = attributes[attribute]
}

import org.jsoup.Jsoup

private fun org.jsoup.nodes.Element.convert(): Element {
    return Element(
        tagName = tagName(),
        innerHTML = html(),
        textContent = text(),
        attributes = attributes().asList().associate { it.key to it.value },
        children = children().map { it.convert() }
    )
}

internal actual fun Document.querySelectorAll(selector: String): List<Element> {
    val doc = Jsoup.parse(html)
    return doc.select(selector).map { it.convert() }
}

// Use an engine from different platforms
internal expect val engine: HttpClientEngine

// Initialize our client
internal val client
    get() = HttpClient(engine) {
        expectSuccess = false
        followRedirects = false
    }

// Internal method to retrieve a document by its URL
internal suspend fun String.fetchDocument(useToken: Boolean = true): Document {
    val res = client.get(this) {
        headers {
            append("User-Agent", "Ktor HTTP Client, Tabroom API v1")

            append("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
            append("Accept-Language", "en-US,en;q=0.9")
            append("Connection", "keep-alive")
            append("Upgrade-Insecure-Requests", "1")
        }

        if (isLoggedIn && useToken)
            cookie("TabroomToken", token!!) // Use the "Cookie" function to set the cookie
    }

    if (!res.status.isSuccess()) throw IOException("Failed to fetch document: ${res.status}\n${res.bodyAsText(Charsets.UTF_8)}") // Print out the error message

    val text = res.bodyAsText(Charsets.UTF_8)
    return Document(this, text)
}

// Platform-specific url encoding/decoding
expect fun encodeURL(url: String): String
expect fun decodeURL(url: String): String


/**
 * Whether the API has currently stored a Session ID.
 */
val isLoggedIn: Boolean
    get() = token != null

/**
 * The current Session ID for the API.
 */
var token: String? = null
    private set

private suspend fun getSaltAndSha(): Pair<String, String> {
    val document = "https://www.tabroom.com/user/login/login.mhtml".fetchDocument() // Read and Parse HTML
    val salt = document.inputValue("salt") ?: throw IllegalStateException("Salt not found in document")
    val sha = document.inputValue("sha") ?: throw IllegalStateException("SHA not found in document")

    return Pair(salt, sha)
}

/**
 * Logs in to Tabroom with the given username and password.
 *
 * This function performs a login request to Tabroom and stores the authentication token in the `token` variable.
 * Tokens represent the Session ID and are valid for 1,024 hours, or roughly 42 days.
 * 
 * @param username The username to log in with.
 * @param password The password to log in with.
 * @return True if the login was successful, false otherwise.
 * @throws IOException If the login request fails.
 */
@JsName("loginAsync")
@JvmName("loginAsync")
suspend fun login(username: String, password: String): Boolean {
    val (salt, sha) = getSaltAndSha()

    val res = client.submitForm(
        "https://www.tabroom.com/user/login/login_save.mhtml",
        parameters {
            append("tourn_id", "")
            append("key", "")
            append("salt", salt)
            append("sha", sha)
            append("category_id", "")
            append("return", "")
            append("username", username)
            append("password", password)
        }
    ) {
        headers {
            append("User-Agent", "Ktor HTTP Client, Tabroom API v1")
            append("Content-Type", "application/x-www-form-urlencoded")
            append("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
        }
    }

    // Redirect value of 302 means sucess; Don't be fooled by a 200 or something else
    if (res.status.value != 302) throw IOException("Unexpected status code: ${res.status}")

    val cookie = res.setCookie() // Retrieve the value of 'Set-Cookie'
    if (cookie.isEmpty()) return false

    val tabToken = cookie.firstOrNull { it.name == "TabroomToken" }?.value // Get the value of 'TabroomToken'
    if (tabToken == null) return false
    if (tabToken.isEmpty()) throw IllegalStateException("TabroomToken is empty")

    token = decodeURL(tabToken) // Set the token variable to the decoded value
    return true
}