ykonsole2/ykonsole-ktor/src/main/kotlin/net/aiterp/git/ykonsole2/application/routes/Workouts.kt

package net.aiterp.git.ykonsole2.application.routes

import io.ktor.http.*
import io.ktor.http.HttpStatusCode.Companion.BadRequest
import io.ktor.http.HttpStatusCode.Companion.NotFound
import io.ktor.http.HttpStatusCode.Companion.OK
import io.ktor.server.application.*
import io.ktor.server.request.*
import io.ktor.server.routing.*
import net.aiterp.git.ykonsole2.domain.models.*
import net.aiterp.git.ykonsole2.infrastructure.ktor.ykDataResponse
import net.aiterp.git.ykonsole2.infrastructure.ktor.ykStatusResponse
import net.aiterp.git.ykonsole2.infrastructure.ktor.ykException

data class WorkoutInput(val deviceId: String, val programId: String? = null)

fun Route.workouts(
  deviceRepo: DeviceRepository,
  programRepo: ProgramRepository,
  workoutRepo: WorkoutRepository,
) {
  route("/workouts") {
    get {
      val workouts = workoutRepo.fetchAll()
      val devices = deviceRepo.fetchAll()
      val programs = programRepo.fetchAll()

      val output = workouts.map { workout ->
        WorkoutDTO(
          workout = workout,
          device = devices.firstOrNull { it.id == workout.deviceId },
          program = workout.programId?.let { programId ->
            programs.firstOrNull { it.id == programId }
          }
        )
      }

      call.ykDataResponse(output)
    }

    post {
      workoutRepo.findActive()?.let {
        throw call.ykException(BadRequest, "Workout already active: ${it.id}")
      }

      val input = call.receive<WorkoutInput>()

      val device = deviceRepo.findById(input.deviceId) ?: throw call.ykException(BadRequest, "Invalid device ID")
      val program = input.programId?.let { progId ->
        programRepo.findById(progId) ?: throw call.ykException(BadRequest, "Invalid program ID")
      }

      val workout = Workout(deviceId = device.id, programId = program?.id)

      workoutRepo.save(workout)
      call.ykDataResponse(WorkoutDTO(workout, device, program))
    }

    get("/active") {
      val workout = workoutRepo.findActive()
      if (workout != null) {
        val device = deviceRepo.findById(workout.deviceId)
        val program = workout.programId?.let { programRepo.findById(it) }

        call.ykDataResponse(WorkoutDTO(workout, device, program))
      } else call.ykStatusResponse(OK, "No active workout")
    }

    route("/{id}") {
      get {
        val id = call.parameters["id"] ?: ""

        val workout = workoutRepo.findById(id) ?: throw call.ykException(NotFound)
        val device = deviceRepo.findById(workout.deviceId)
        val program = workout.programId?.let { programRepo.findById(it) }

        call.ykDataResponse(WorkoutDTO(workout, device, program))
      }

      delete {
        val id = call.parameters["id"] ?: ""

        val workout = workoutRepo.findById(id) ?: throw call.ykException(NotFound)
        if (workout.status != WorkoutStatus.Disconnected) {
          throw call.ykException(BadRequest, "Please quit the workout before deleting it")
        }

        workoutRepo.delete(workout)
        call.ykDataResponse(null)
      }
    }
  }
}