LernApp/src/main/kotlin/com/oliver/kidio/backend/plugins/Routing.kt

package com.oliver.kidio.backend.plugins

import com.oliver.kidio.backend.*
import com.oliver.kidio.backend.domain.repository.KidioRepository
import com.oliver.kidio.backend.security.JwtService
import io.ktor.server.application.*
import io.ktor.server.auth.authenticate
import io.ktor.server.request.*
import io.ktor.server.response.*
import io.ktor.server.routing.*

fun Application.configureRouting(repository: KidioRepository, jwtService : JwtService) {
    routing {

        // Health-Check
        get("/api/v1/health") {
            call.respond(mapOf("status" to "OK", "message" to "Kidio Backend läuft!"))
        }

        post ("/api/v1/auth/login" )   {
            val loginRequest = call.receive<LoginRequest>()

            val token = jwtService.generateToken(userId = loginRequest.userId)
            call.respond(mapOf("token" to token))
        }

        authenticate("auth-jwt") {

            // 1. Alle verfügbaren Aufgaben abrufen
            get("/api/v1/tasks") {
                val tasks = repository.getAllTasks()
                call.respond(tasks)
            }

            // 2. Antwort auf eine Aufgabe überprüfen
            post("/api/v1/tasks/verify") {
                val request = call.receive<TaskVerifyRequest>()

                val taskInfo = repository.getTaskAnswerAndReward(request.taskId)

                if (taskInfo == null) {
                    call.respond(
                        TaskVerifyResponse(
                            isCorrect = false,
                            earnedMinutes = 0,
                            message = "Aufgabe nicht gefunden!"
                        )
                    )
                    return@post
                }

                val (correctAnswer, reward) = taskInfo
                val isCorrect = request.selectedAnswer.trim() == correctAnswer.trim()

                if (isCorrect) {
                    val currentScreentime = repository.getScreentime("default_user")
                    val newSeconds = currentScreentime + (reward * 60)
                    repository.updateScreentime("default_user", newSeconds)

                    call.respond(
                        TaskVerifyResponse(
                            isCorrect = true,
                            earnedMinutes = reward,
                            message = "Super gemacht! Du hast $reward Minuten gewonnen."
                        )
                    )
                } else {
                    call.respond(
                        TaskVerifyResponse(
                            isCorrect = false,
                            earnedMinutes = 0,
                            message = "Schade, das war leider falsch. Versuche es nochmal!"
                        )
                    )
                }
            }

            // 3. Bildschirmzeit synchronisieren
            post("/api/v1/screentime/sync") {
                val request = call.receive<SyncRequest>()

                val currentSeconds = repository.getScreentime(request.userId)
                var newSeconds = currentSeconds - request.usedSecondsSinceLastSync
                if (newSeconds < 0) newSeconds = 0

                repository.updateScreentime(request.userId, newSeconds)

                call.respond(
                    SyncResponse(
                        remainingSeconds = newSeconds,
                        isBlocked = newSeconds <= 0
                    )
                )
            }
        }
    }
}