import com.cndtns.auth.UserSession
import com.cndtns.scrapers.strava.models.SummaryActivity
import com.cndtns.strava.StravaConfig
import com.cndtns.strava.stravaOAuthRoutes
import io.ktor.client.*
import io.ktor.client.call.*
import io.ktor.client.engine.cio.*
import io.ktor.client.plugins.contentnegotiation.*
import io.ktor.client.plugins.logging.*
import io.ktor.client.request.*
import io.ktor.http.*
import io.ktor.serialization.kotlinx.json.*
import io.ktor.server.application.*
import io.ktor.server.auth.*
import io.ktor.server.engine.*
import io.ktor.server.html.*
import io.ktor.server.request.*
import io.ktor.server.resources.*
import io.ktor.server.response.*
import io.ktor.server.routing.*
import io.ktor.server.sessions.*
import kotlinx.html.a
import kotlinx.html.body
import kotlinx.html.p
import kotlinx.serialization.json.Json
import org.slf4j.Logger
import org.slf4j.LoggerFactory
import java.lang.invoke.MethodHandles

val applicationHttpClient = HttpClient(CIO) {
    install(Logging) {
        level = LogLevel.BODY
    } // default logging
    install(ContentNegotiation) {
        json(Json {
            ignoreUnknownKeys = true
            isLenient = true
        })
    }
}

fun main() {
    embeddedServer(io.ktor.server.cio.CIO, port = 8080, module = Application::main).start(wait = true)
}


private fun Application.main(httpClient: HttpClient = applicationHttpClient) {
    val redirects = mutableMapOf<String, String>()

    install(Resources) // enable @Resource annotations

    install(Sessions) {
        cookie<UserSession>("user_session")
    }

    install(Authentication) {
        oauth {
            urlProvider = { "<http://localhost:8080/login/authorization-callback>" }
            providerLookup = {
                OAuthServerSettings.OAuth2ServerSettings(
                    name = "strava",
                    authorizeUrl = StravaConfig.AUTH_URL,
                    accessTokenUrl = StravaConfig.TOKEN_URL,
                    requestMethod = <http://HttpMethod.Post|HttpMethod.Post>,
                    clientId = StravaConfig.clientId,
                    clientSecret = StravaConfig.clientSecret,
                    defaultScopes = listOf("activity:read_all,read_all"),
                    extraAuthParameters = listOf("approval_prompt" to "auto", "response_type" to "code"),
                    passParamsInURL = true,
                    onStateCreated = { call, state ->
                        val redirectUrl = call.request.queryParameters["redirectUrl"] ?: ""
                        redirects[state] = redirectUrl
                        println("Redirect URL for state $state is $redirectUrl")
                    },
                )
            }
            client = httpClient
        }
    }

    routing {
        authenticate {
            get("/login/authorization-callback") {
                val principal = call.authentication.principal<OAuthAccessTokenResponse.OAuth2>()
                    ?: throw Exception("No principal was given")
                val accessToken = principal.accessToken // TODO: Validate
                val state = principal.state ?: throw Exception("No state was given")

                call.sessions.set(UserSession(state = state, token = accessToken))
                call.respondRedirect("/")
            }
            get("/login") {
                call.respondRedirect("/")
            }
        }

        get("/") {
            call.respondHtml {
                body {
                    p {
                        a("/login") { +"Login with Strava" }
                    }
                }
            }
        }

        get("/{path}") {
            val userSession: UserSession? = call.sessions.get()
            if (userSession != null) {
                val activities: List<SummaryActivity> = httpClient.get("<https://www.strava/api/v3/athlete/activities>") {
                    headers {
                        append(HttpHeaders.Authorization, "Bearer ${userSession.token}")
                    }
                }.body()
                call.respondText("Here are your activities, ${activities.joinToString(", ") { "${it.id} - ${it.name}" }}!")
            } else {
                val redirectUrl = URLBuilder("<http://localhost:8080/login>").run {
                    parameters.append("redirectUrl", call.request.uri)
                    build()
                }
                call.respondRedirect(redirectUrl)
            }
        }
    }
}

/login/authorization-callback

{
  "access_token": "...",
  "expires_in": 3599,
  "scope": "<https://www.googleapis.com/auth/userinfo.profile>",
  "token_type": "Bearer",
  "id_token": "..."
}

{
   "token_type":"Bearer",
   "expires_at":1678972747,
   "expires_in":14065,
   "refresh_token":"...",
   "access_token":"...",
   "athlete":{} 
   }
}