package com.restapi.controllers

import com.restapi.domain.DataModel
import com.restapi.domain.Session
import com.restapi.domain.Session.database
import com.restapi.domain.Session.findByEntityAndId
import io.ebean.CallableSql
import io.ebean.RawSqlBuilder
import io.javalin.http.Context
import io.javalin.http.NotFoundResponse
import io.javalin.http.bodyAsClass
import org.slf4j.LoggerFactory
import java.time.LocalDateTime

data class PatchValue(val key: String, val value: Any)
data class Query(
    val sql: String,
    val params: Map<String, Any>
)

object Entities {
    private val logger = LoggerFactory.getLogger("Entities")
    fun delete(ctx: Context) {
        val e = database.findByEntityAndId(ctx.pathParam("entity"), ctx.pathParam("id"))
        e.deletedBy = Session.currentUser()
        e.deletedOn = LocalDateTime.now()
        e.update()
        e.delete()
    }

    fun patch(ctx: Context) {
        val e = database.findByEntityAndId(ctx.pathParam("entity"), ctx.pathParam("id"))
        val pv = ctx.bodyAsClass<PatchValue>()
        e.data[pv.key] = pv.value;
        e.update()
    }

    fun update(ctx: Context) {
        val e = database.findByEntityAndId(ctx.pathParam("entity"), ctx.pathParam("id"))
        val newData = ctx.bodyAsClass<Map<String, Any>>()
        e.data.putAll(newData)
        e.update()
    }

    fun action(ctx: Context) {}
    fun approve(ctx: Context) {}
    fun reject(ctx: Context) {}

    fun executeStoredProcedure(ctx: Context) {
        val name = ctx.pathParam("name")
        val params = ctx.bodyAsClass<Map<String, Any>>()
        val placeholders = (0..params.entries.size + 1).joinToString(",") { "?" }

        val sql = "{call $name($placeholders)}"
        val cs: CallableSql = database.createCallableSql(sql)

        params.entries.forEachIndexed { index, entry ->
            cs.setParameter(index + 1, entry.value)
        }
        cs.setParameter(params.entries.size + 1, Session.currentTenant())
        database.execute(cs)
    }

    fun sqlQueryRaw(ctx: Context) {
        val sql = ctx.bodyAsClass<Query>()
        ctx.json(
            database.find(DataModel::class.java)
                .setRawSql(
                    RawSqlBuilder.parse(sql.sql).create()
                ).apply {
                    sql.params.forEach { (t, u) ->
                        setParameter(t, u)
                    }
                }
                .findList()
        )

    }

    fun sqlQueryId(ctx: Context) {
        val sql = ctx.bodyAsClass<Query>()
        val query = database.findByEntityAndId(ctx.pathParam("entity"), ctx.pathParam("id"))

        val querySql = query.data["sql"] as String? ?: throw NotFoundResponse()

        ctx.json(
            database.find(DataModel::class.java)
                .setRawSql(
                    RawSqlBuilder.parse(querySql).create()
                ).apply {
                    sql.params.forEach { (t, u) ->
                        setParameter(t, u)
                    }
                }
                .findList()
        )

    }

    fun view(it: Context) {
        it.json(
            database.findByEntityAndId(it.pathParam("entity"), it.pathParam("id"))
        )
    }

    fun create(ctx: Context) {
        val entity = ctx.pathParam("entity")
        val seqCreated = Session.creatSeq(entity)
        logger.debug("sequence created for $entity? = $seqCreated")
        database.save(
            ctx.bodyAsClass<DataModel>().apply {
                this.entityName = entity
                if (this.uniqueIdentifier.isEmpty()) {
                    this.uniqueIdentifier = Session.nextUniqId(entity)
                }
            }
        )
    }
}