package be.vandewalleh

import be.vandewalleh.features.Config
import be.vandewalleh.features.configurationModule
import be.vandewalleh.features.loadFeatures
import be.vandewalleh.migrations.Migration
import be.vandewalleh.routing.registerRoutes
import be.vandewalleh.services.serviceModule
import io.ktor.application.*
import io.ktor.routing.*
import io.ktor.server.engine.*
import io.ktor.server.netty.*
import me.liuwj.ktorm.database.*
import org.kodein.di.Kodein
import org.kodein.di.description
import org.kodein.di.generic.bind
import org.kodein.di.generic.instance
import org.kodein.di.generic.singleton
import org.slf4j.Logger
import org.slf4j.LoggerFactory
import javax.sql.DataSource

val kodein = Kodein {
    import(serviceModule)
    import(configurationModule)
    bind<Logger>() with singleton { LoggerFactory.getLogger("Application") }
    bind<Migration>() with singleton { Migration(this.kodein) }
    bind<Database>() with singleton { Database.connect(this.instance<DataSource>()) }
}

fun main() {
    val config by kodein.instance<Config>()
    val logger by kodein.instance<Logger>()
    logger.info("Running application with configuration $config")
    logger.info("Kodein bindings\n${kodein.container.tree.bindings.description()}")
    val migration by kodein.instance<Migration>()
    migration.migrate()
    serve(kodein)
}

fun serve(kodein: Kodein) {
    val config by kodein.instance<Config>()
    val logger by kodein.instance<Logger>()
    val env = applicationEngineEnvironment {
        module {
            module()
        }
        log = logger
        connector {
            host = config.server.host
            port = config.server.port
        }
    }
    embeddedServer(Netty, env).start(wait = true)
}


fun Application.module() {
    loadFeatures()

    log.debug(kodein.container.tree.bindings.description())

    routing {
        registerRoutes(kodein)
    }

    val root = feature(Routing)
    val allRoutes = allRoutes(root)
    allRoutes.forEach {
        println(it.toString())
    }

}

fun allRoutes(root: Route): List<Route> {
    return listOf(root) + root.children.flatMap { allRoutes(it) }
}