chookchat/server/src/main/kotlin/Main.kt

package xyz.maxwellj.chookpen

import io.javalin.Javalin
import io.javalin.websocket.WsContext
import java.util.concurrent.ConcurrentHashMap
import java.util.UUID

import java.io.File
import java.io.BufferedReader
/*
object WsSessionManager {
    val sessions = ConcurrentHashMap<String, WsContext>()
    fun addSession(sessionID: String, ctx: WsContext) {
        sessions[sessionID] = ctx
    }
    fun removeSession(sessionID: String) {
        sessions.remove(sessionID)
    }
    fun broadcast(message: String) {
        sessions.values.forEach { ctx ->
            ctx.send(message)
        }
    }
}
*/
object WsSessionManager {
    private val sessions = ConcurrentHashMap<String, WsContext>()

    fun addSession(ctx: WsContext) {
        // Generate our own UUID for the session since we can't access Javalin's private sessionId
        val sessionId = UUID.randomUUID().toString()
        sessions[sessionId] = ctx
    }

    fun removeSession(ctx: WsContext) {
        // Find and remove the session by context
        sessions.entries.removeIf { it.value === ctx }
    }

    fun broadcast(message: String) {
        sessions.values.forEach { ctx ->
            ctx.send(message)
        }
    }
}

fun extractMessageContent(inputData: String): String {
    var username = ""
    var message = ""
    var dataType = ""
    var isParsingData = 0
    
    for (char in inputData) {
        if (char == ':') {
            isParsingData = 1
        } else if (isParsingData == 1) {
            if (char == '}') {
                isParsingData = 0
                dataType = ""
            } else if (char != '{') {
                if (dataType == "username") {
                    username += char
                } else if (dataType == "message") {
                    message += char
                }
            }
        } else {
            dataType += char
        }
    }
    
    return("$username: $message")
}

fun handleSentMessage(inputData: String): String {
    println("API request recieved: $inputData")
    // Parse data sent to the server by client
    var username = ""
    var token = ""
    var message = ""
    var dataType = ""
    var isParsingData = 0
    for (char in inputData) {
        val character = char
        if (character == ':') {
            isParsingData = 1
        } else if (isParsingData == 1) {
            if (character == '}') {
                isParsingData = 0
                dataType = ""
            } else if (character != '{') {
                if (dataType == "username") {
                    username += character
                } else if (dataType == "token") {
                    token += character
                } else if (dataType == "message") {
                    message += character
                }
            }
        } else {
            dataType += character
        }
    }
    val userDatabaseParser = BufferedReader(File("userDatabase").reader())
    var lineNumber = 1
    var userLine = ""
    
    // Search the user database to find required information about the user
    userDatabaseParser.forEachLine { line ->
        if (line.contains(username)) {
            userLine = line
        }
        lineNumber++
    }
    userDatabaseParser.close()

    if (userLine == "") {
        return("That account does not exist on this server.")
    }
 
    var usernameInDatabase = ""
    var tokenInDatabase = ""
    var currentStage = 0
    for (char in userLine) {
        if (char == ':') {
            currentStage ++
        }
        if (currentStage == 0) {
            usernameInDatabase += char
        } else if (currentStage == 1) {
            tokenInDatabase += char
        }
    }
    tokenInDatabase = tokenInDatabase.replace(":", "")
    if (token != tokenInDatabase)  {
        return("Invalid token! Please try putting in your password right")
    }
    // Make the message to respond to the client
    val chatHistoryView = File("chatHistory")
    var fullMessage = ""
    if (message != "") {
        fullMessage = "${chatHistoryView.readText()}$username: $message"
        // Add the client's message to the chat history
        val chatHistory = File("chatHistory")
        chatHistory.appendText("$username: $message ${System.lineSeparator()}")
        message = ""
        return("Success")
    } else {
        return("No data provided")
    }
}

fun syncMessages(inputData: String): String {
    println("API request recieved: $inputData")
    // Parse data sent to the server by client
    var username = ""
    var token = ""
    var dataType = ""
    var isParsingData = 0
    for (char in inputData) {
        val character = char
        if (character == ':') {
            isParsingData = 1
        } else if (isParsingData == 1) {
            if (character == '}') {
                isParsingData = 0
                dataType = ""
            } else if (character != '{') {
                if (dataType == "username") {
                    username += character
                } else if (dataType == "token") {
                    token += character
                }
            }
        } else {
            dataType += character
        }
    }
    val userDatabaseParser = BufferedReader(File("userDatabase").reader())
    var lineNumber = 1
    var userLine = ""
    
    // Search the user database to find required information about the user
    userDatabaseParser.forEachLine { line ->
        if (line.contains(username)) {
            userLine = line
        }
        lineNumber++
    }
    userDatabaseParser.close()

    if (userLine == "") {
        return("Account not found")
    }
 
    var usernameInDatabase = ""
    var tokenInDatabase = ""
    var currentStage = 0
    for (char in userLine) {
        if (char == ':') {
            currentStage ++
        }
        if (currentStage == 0) {
            usernameInDatabase += char
        } else if (currentStage == 1) {
            tokenInDatabase += char
        }
    }
    tokenInDatabase = tokenInDatabase.replace(":", "")
    if (token != tokenInDatabase)  {
        return("Invalid token")
    }
    // Send back message history 
    val chatHistoryView = File("chatHistory")
    return(chatHistoryView.readText())
}

fun createAccount(inputData: String): String {
    println("Account creation request recieved: $inputData")
    // Parse data sent to the server by client
    var username = ""
    var token = ""
    var message = ""
    var dataType = ""
    var isParsingData = 0
    for (char in inputData) {
        val character = char
        if (character == ':') {
            isParsingData = 1
        } else if (isParsingData == 1) {
            if (character == '}') {
                isParsingData = 0
                dataType = ""
            } else if (character != '{') {
                if (dataType == "username") {
                    username += character
                } else if (dataType == "token") {
                    token += character
                } else if (dataType == "message") {
                    message += character
                }
            }
        } else {
            dataType += character
        }
    }
    val userDatabaseParser = BufferedReader(File("userDatabase").reader())
    var lineNumber = 1
    var userExists = 0
    
    // Search the user database to find required information about the user
    var response = ""
    userDatabaseParser.forEachLine { line ->
        if (line.contains(username)) {
            response = "Username already exists"
        }
        lineNumber++
    }
    if (response != "") {
        return(response)
    }
    userDatabaseParser.close()
    if (username == "") {
        return("No username")
    }

    if (token == "") {
        return("No token")
    }

    val userDatabaseFile = File("userDatabase")
    userDatabaseFile.appendText("${System.lineSeparator()}$username:$token")
    return("Success")
}
fun authKey(inputData: String): String {
    println("API request recieved: $inputData")
       
    // Parse data sent to the server by client
    var username = ""
    var token = ""
    var authKey = ""
    var dataType = ""
    var isParsingData = 0
    for (char in inputData) {
        val character = char
        if (character == ':') {
            isParsingData = 1
        } else if (isParsingData == 1) {
            if (character == '}') {
                isParsingData = 0
                dataType = ""
            } else if (character != '{') {
                if (dataType == "username") {
                    username += character
                } else if (dataType == "token") {
                    token += character
                } else if (dataType == "authkey") {
                    authKey += character
                }
            }
        } else {
            dataType += character
        }
    }
    val userDatabaseParser = BufferedReader(File("userDatabase").reader())
    var lineNumber = 1
    var userLine = ""
    
    // Search the user database to find required information about the user
    userDatabaseParser.forEachLine { line ->
        if (line.contains(username)) {
            userLine = line
        }
        lineNumber++
    }
    userDatabaseParser.close()

    if (userLine == "") {
        return("Account not found")
    }
 
    var usernameInDatabase = ""
    var tokenInDatabase = ""
    var currentStage = 0
    for (char in userLine) {
        if (char == ':') {
            currentStage ++
        }
        if (currentStage == 0) {
            usernameInDatabase += char
        } else if (currentStage == 1) {
            tokenInDatabase += char
        }
    }
    tokenInDatabase = tokenInDatabase.replace(":", "")
    if (token != tokenInDatabase)  {
        return("Invalid token")
    }
    if (authKey == "") {
        return("No auth key provided")
    }
    // Make the message to respond to the client
    val chatHistoryView = File("chatHistory")
    var fullMessage = ""
    if (authKey != "") {
        fullMessage = "encryptionKey:$username:$authKey"
        authKey = ""
    } else {
        fullMessage = "${chatHistoryView.readText()}"
    }
    val response = if (inputData.isNotEmpty()) {
        fullMessage            
    } else {
        "No data provided"
    }

    // Send the message to the client
    return("Success")
}

fun main(args: Array<String>) {
    val app = Javalin.create()
        .get("/") { ctx -> ctx.result("dingus") }
        .get("/api/send/{content}") { ctx -> 
            val result = handleSentMessage(ctx.pathParam("content"))
            if (result == "Success") {
                val messageContent = extractMessageContent(ctx.pathParam("content"))
                WsSessionManager.broadcast(messageContent)
            }
            ctx.result(result)
        }
        .get("/api/createaccount/{content}") { ctx -> ctx.result(createAccount(ctx.pathParam("content")))}
        .get("/api/syncmessages/{content}") { ctx -> ctx.result(syncMessages(ctx.pathParam("content")))}
        .get("/api/authkey/{content}") { ctx -> ctx.result(authKey(ctx.pathParam("content")))}
        .ws("/api/websocket") { ws -> 
            ws.onConnect { ctx -> 
                WsSessionManager.addSession(ctx)
                ctx.send("Websocket success")
            }
            ws.onClose { ctx ->
                WsSessionManager.removeSession(ctx)
            }
            ws.onMessage { ctx -> 
                println(ctx.message()) 
                val successState = handleSentMessage(ctx.message())
                if (successState != "Success") {
                    ctx.send(successState)
                } else {
                    // Broadcast the message to all clients if successful
                    val messageContent = extractMessageContent(ctx.message())
                    WsSessionManager.broadcast(messageContent)
                    ctx.send("Message sent successfully")
                }
            } 
        }
        .start(7070)
}

/*
fun main(args: Array<String>) {
    val app = Javalin.create()
        .get("/") { ctx -> ctx.result("dingus") }
        .get("/api/send/{content}") { ctx -> 
            val result = handleSentMessage(ctx.pathParam("content"))
            if (result == "Success") {
                val messageContent = extractMessageContent(ctx.pathParam("content")
                WsSessionManager.broadcast(messageContent)
            ctx.result(result)
            }
        }
        .get("/api/createaccount/{content}") { ctx -> ctx.result(createAccount(ctx.pathParam("content")))}
        .get("/api/syncmessages/{content}") { ctx -> ctx.result(syncMessages(ctx.pathParam("content")))}
        .get("/api/authkey/{content}") { ctx -> ctx.result(authKey(ctx.pathParam("content")))}
        .ws("/api/websocket") { ws -> 
            ws.onConnect { ctx -> 
                WsSessionManager.addSession(ctx.sessionId, ctx)
                ctx.send("Websocket success")
            }
            ws.onClose { ctx ->
                WsSessionManager.removeSession(ctx.sessionId)
            }
            ws.onMessage { ctx -> 
                println(ctx.message()) 
                val successState = handleSentMessage(ctx.message())
                if (successState != "Success") {
                    ctx.send(successState)
                } else {
                    ctx.send("Message sent successfully")
                }
            } 
        }
    .start(7070)
}*/