Ktor Error Handling

install(StatusPages) {
    exception<NotFoundException> { call, cause ->
        call.respond(HttpStatusCode.NotFound, mapOf("code" to "NOT_FOUND", "message" to cause.message))
    }
    exception<UnauthorizedException> { call, cause ->
        call.respond(HttpStatusCode.Unauthorized, mapOf("code" to "UNAUTHORIZED", "message" to cause.message))
    }
    exception<Throwable> { call, cause ->
        call.respond(HttpStatusCode.InternalServerError, mapOf("code" to "INTERNAL", "message" to "Terjadi kesalahan"))
    }
}

// ktor_error_handling.kt
// Mendemonstrasikan plugin StatusPages pada Ktor: memetakan exception
// ke respons HTTP, custom exception handler, dan fallback.

import kotlin.reflect.KClass

// Custom exceptions
open class AppException(val statusCode: Int, val code: String, message: String) : RuntimeException(message)
class NotFoundException(resource: String) : AppException(404, "NOT_FOUND", "Resource $resource tidak ditemukan")
class UnauthorizedException(msg: String = "Token tidak valid") : AppException(401, "UNAUTHORIZED", msg)
class ConflictException(msg: String) : AppException(409, "CONFLICT", msg)

// StatusPages: pasang handler per tipe exception
class StatusPages {
    private val handlers = mutableMapOf<KClass<*>, (AppException) -> Pair<Int, String>>()
    var fallback: ((Throwable) -> Pair<Int, String>)? = null

    @PublishedApi
    internal fun putHandler(k: KClass<*>, h: (AppException) -> Pair<Int, String>) {
        handlers[k] = h
    }

    inline fun <reified T : AppException> exception(noinline handler: (T) -> Pair<Int, String>) {
        @Suppress("UNCHECKED_CAST")
        putHandler(T::class, handler as (AppException) -> Pair<Int, String>)
    }

    fun handleException(ex: Throwable): Pair<Int, String> {
        if (ex is AppException) {
            val handler = handlers[ex::class]
            if (handler != null) return handler(ex)
        }
        return fallback?.invoke(ex)
            ?: (500 to """{"code":"INTERNAL","message":"Terjadi kesalahan internal"}""")
    }
}

// Mock ApplicationCall
class ApplicationCall {
    var responseStatus: Int = 200
    var responseBody: String = ""
    var requestPath: String = ""
}

// Pipeline eksekusi handler
class Application(val statusPages: StatusPages) {
    fun handle(call: ApplicationCall, block: () -> String) {
        try {
            call.responseBody = block()
            call.responseStatus = 200
        } catch (ex: Throwable) {
            val (status, body) = statusPages.handleException(ex)
            call.responseStatus = status
            call.responseBody = body
        }
    }
}

fun main() {
    val statusPages = StatusPages().apply {
        exception<NotFoundException> { ex ->
            404 to """{"code":"${ex.code}","message":"${ex.message}"}"""
        }
        exception<UnauthorizedException> { ex ->
            401 to """{"code":"${ex.code}","message":"${ex.message}"}"""
        }
        exception<ConflictException> { ex ->
            409 to """{"code":"${ex.code}","message":"${ex.message}"}"""
        }
        fallback = { ex ->
            500 to """{"code":"INTERNAL","message":"Kesalahan tidak terduga: ${ex.message}"}"""
        }
    }

    val app = Application(statusPages)

    println("=== Request: berhasil ===")
    val c1 = ApplicationCall().apply { requestPath = "/users/1" }
    app.handle(c1) { """{"id":1,"nama":"Budi"}""" }
    println("Status: ${c1.responseStatus}, Body: ${c1.responseBody}")

    println("\n=== Request: not found ===")
    val c2 = ApplicationCall().apply { requestPath = "/users/999" }
    app.handle(c2) { throw NotFoundException("User dengan id 999") }
    println("Status: ${c2.responseStatus}, Body: ${c2.responseBody}")

    println("\n=== Request: unauthorized ===")
    val c3 = ApplicationCall().apply { requestPath = "/me" }
    app.handle(c3) { throw UnauthorizedException() }
    println("Status: ${c3.responseStatus}, Body: ${c3.responseBody}")

    println("\n=== Request: conflict ===")
    val c4 = ApplicationCall().apply { requestPath = "/users" }
    app.handle(c4) { throw ConflictException("Email sudah dipakai") }
    println("Status: ${c4.responseStatus}, Body: ${c4.responseBody}")

    println("\n=== Request: error internal ===")
    val c5 = ApplicationCall().apply { requestPath = "/pay" }
    app.handle(c5) { error("Koneksi database timeout") }
    println("Status: ${c5.responseStatus}, Body: ${c5.responseBody}")
}

=== Request: berhasil ===
Status: 200, Body: {"id":1,"nama":"Budi"}

=== Request: not found ===
Status: 404, Body: {"code":"NOT_FOUND","message":"Resource User dengan id 999 tidak ditemukan"}

=== Request: unauthorized ===
Status: 401, Body: {"code":"UNAUTHORIZED","message":"Token tidak valid"}

=== Request: conflict ===
Status: 409, Body: {"code":"CONFLICT","message":"Email sudah dipakai"}

=== Request: error internal ===
Status: 500, Body: {"code":"INTERNAL","message":"Kesalahan tidak terduga: Koneksi database timeout"}