Retrofit

	implementation("com.squareup.retrofit2:retrofit:2.11.0")
	implementation("com.squareup.retrofit2:converter-jackson:2.11.0")

	implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.0")

interface CoffeeApiClient {
	@POST("coffee")
	suspend fun updateCoffee(@Body request: CoffeeRequest, @Query("coffeeId") coffeeId: Int): Response<Unit>
}

class CoffeeApiClientFactory(
	private val jsonMapper: ObjectMapper,
	private val config: Config,
	private val tokenAuthenticator: TokenAuthenticator,
	private val defaultHeadersInterceptor: DefaultHeadersInterceptor,
	private val defaultParamsInterceptor: DefaultParamsInterceptor,
	private val tokenInterceptor: TokenInterceptor,
): ClientFactory<CoffeeApiClient> {

	override fun createClient(): CoffeeApiClient {

		val client = OkHttpClient.Builder()
			.addInterceptor(tokenInterceptor)
			.authenticator(tokenAuthenticator)
			.addInterceptor(defaultHeadersInterceptor)
			.addInterceptor(defaultParamsInterceptor)
			.build()

		val retrofit = Retrofit.Builder()
			.client(client)
			.baseUrl(config.baseUrl!!)
			.addConverterFactory(JacksonConverterFactory.create(jsonMapper))
			.build()

		val service: CoffeeApiClient = retrofit.create(CoffeeApiClient::class.java)
		return service
	}

}

class TokenInterceptor(
	private val tokenRepository: TokenRepository
) : Interceptor {

	override fun intercept(chain: Interceptor.Chain): Response {
		val accessToken: String? = tokenRepository.getAccessToken()
		val request: Request = newRequestWithAccessToken(chain.request(), accessToken)
		val response: Response = chain.proceed(request)

		return response
	}

	private fun newRequestWithAccessToken(request: Request, accessToken: String?): Request {
		if(accessToken == null) return request
		return request.newBuilder()
			.header("Authorization", "Bearer $accessToken")
			.build()
	}
}

class TokenAuthenticator(
	private val tokenRepository: TokenRepository
) : Authenticator {

	// AtomicBoolean in order to avoid race condition
	private var tokenRefreshInProgress: AtomicBoolean = AtomicBoolean(false)
	private var request: Request? = null

	override fun authenticate(route: Route?, response: Response): Request? {
		return runBlocking {
			request = null

			// Checking if a token refresh call is already in progress or not
			// The first request will enter the if block
			// Later requests will enter the else block
			if (!tokenRefreshInProgress.get()) {
				tokenRefreshInProgress.set(true)
				// Refreshing token
				refreshToken()
				request = buildRequest(response.request.newBuilder())
				tokenRefreshInProgress.set(false)
			} else {
				// Waiting for the ongoing request to finish
				// So that we don't refresh our token multiple times
				waitForRefresh(response)
			}

			// return null to stop retrying once responseCount returns 3 or above.
			if (responseCount(response) >= 3) {
				null
			} else request
		}
	}

	// Refresh your token here and save them.
	private suspend fun refreshToken() {
		// Simulating a token refresh request
		delay(200)
		tokenRepository.refreshToken()
		delay(200)
	}

	// Queuing the requests with delay
	private suspend fun waitForRefresh(response: Response) {
		while (tokenRefreshInProgress.get()) {
			delay(100)
		}
		request = buildRequest(response.request.newBuilder())
	}

	private fun responseCount(response: Response?): Int {
		var result = 1
		while (response?.priorResponse != null && result <= 3) {
			result++
		}
		return result
	}

	// Build a new request with new access token
	private fun buildRequest(requestBuilder: Request.Builder): Request {
		val token = tokenRepository.getAccessToken()
		return requestBuilder
			.header(HEADER_CONTENT_TYPE, HEADER_CONTENT_TYPE_VALUE)
			.header(HEADER_AUTHORIZATION, HEADER_AUTHORIZATION_TYPE + token)
			.build()
	}

	companion object {
		const val HEADER_AUTHORIZATION = "Authorization"
		const val HEADER_CONTENT_TYPE = "Content-Type"
		const val HEADER_CONTENT_TYPE_VALUE = "application/json"
		const val HEADER_AUTHORIZATION_TYPE = "Bearer "
	}
}

class DefaultHeadersInterceptor() : Interceptor {
	override fun intercept(chain: Interceptor.Chain): Response {
		val originalRequest = chain.request()

		val modifiedRequest = originalRequest.newBuilder()
			.addHeader("CustomHeaderParam", "42")
			.build()
		return chain.proceed(modifiedRequest)
	}
}

class DefaultParamsInterceptor() : Interceptor {
	override fun intercept(chain: Interceptor.Chain): Response {
		val originalRequest = chain.request()

		val modifiedRequest = originalRequest.newBuilder()
			.url(originalRequest.url.newBuilder()
				.addQueryParameter("queryParam", "someValue")
				.build())
			.build()
		return chain.proceed(modifiedRequest)
	}
}