output-service-rdb/src/api/route/OutputServiceRDBServer.kt

package com.kmalbz.api.route

import com.kmalbz.database.service.IResultObjectService
import io.ktor.application.call
import io.ktor.http.HttpStatusCode
import io.ktor.response.respond
import io.ktor.routing.Routing
import io.ktor.routing.get
import org.koin.ktor.ext.inject
import java.time.LocalDate
import java.time.format.DateTimeFormatter
import kotlin.math.ceil
import kotlin.math.roundToInt

/**
 * Output Service - RDB
 *
 * This is the output interface of the Birbnetes system.
 */
class OutputServiceRDBServer {
    /**
     * output
     */

    fun Routing.registerOutput() {
        val resultObjectService: IResultObjectService by inject()
        get("/output") {
            call.respond(resultObjectService.getAllResultObjects())
        }

        get("/output/count") {
            call.respond(resultObjectService.getAllResultObjects().size)
        }

        get("/output/page/{page}") {
            val page = call.parameters["page"] ?: error(HttpStatusCode.NotAcceptable)
            val pageNum = page.toLong()
            call.respond(resultObjectService.getPage(pageNum))
        }

        get("/output/filter/negative") {
            val resultList =
                resultObjectService.getResultObjecLessthanProbability(0.5) ?: call.respond(HttpStatusCode.NotFound)

            call.respond(resultList)
        }

        get("/output/filter/positive") {
            val resultList =
                resultObjectService.getResultObjecGreaterthanProbability(0.5) ?: call.respond(HttpStatusCode.NotFound)

            call.respond(resultList)
        }

        get("/output/filter/undecided") {
            val resultList =
                resultObjectService.getResultObjecEqualsProbability(0.5) ?: call.respond(HttpStatusCode.NotFound)

            call.respond(resultList)
        }

        get("/output/after/{dateAfter}") {
            val dateAfter = call.parameters["dateAfter"] ?: error(HttpStatusCode.NotAcceptable)
            val dateTimeFormatter: DateTimeFormatter = DateTimeFormatter.ISO_LOCAL_DATE
            val localDateAfter: LocalDate = LocalDate.parse(dateAfter, dateTimeFormatter)
            val resultList =
                resultObjectService.getResultObjectafterDate(localDateAfter) ?: call.respond(HttpStatusCode.NotFound)

            call.respond(resultList)
        }

        get("/output/before/{dateBefore}") {
            val dateAfter = call.parameters["dateBefore"] ?: error(HttpStatusCode.NotAcceptable)
            val dateTimeFormatter: DateTimeFormatter = DateTimeFormatter.ISO_LOCAL_DATE
            val localDateBefore: LocalDate = LocalDate.parse(dateAfter, dateTimeFormatter)
            val resultList =
                resultObjectService.getResultObjectbeforeDate(localDateBefore) ?: call.respond(HttpStatusCode.NotFound)

            call.respond(resultList)
        }

        get("/output/{tagID}") {
            val tagID = call.parameters["tagID"] ?: error(HttpStatusCode.NotAcceptable)
            val resultObject = resultObjectService.getResultObjectbyTag(tagID) ?: call.respond(HttpStatusCode.NotFound)

            call.respond(resultObject)
        }
    }
}