inline fun <reified T> AssetManager.loadAsync(
  path: String, parameters: AssetLoaderParameters<T>? = null
): Deferred<T> = loadAsync(AssetDescriptor(path, T::class.java, parameters))

fun <T> AssetManager.loadAsync(assetDescriptor: AssetDescriptor<T>): Deferred<T> {
  synchronized(this) {
    // isLoaded and get are both synchronized. We want to perform these in a single step.
    if (isLoaded(assetDescriptor)) {
      // Increasing reference count:
      load(assetDescriptor)
      // Returning loaded instance:
      return CompletableDeferred(this[assetDescriptor])
    }
  }
  val result = CompletableDeferred<T>()

  // We can complete the deferred via loaded callback. However, parameters can be null.
  val path = assetDescriptor.fileName
  val parameters = assetDescriptor.params
    ?: getDefaultParametersForLoader<T>(getLoader(assetDescriptor.type, path), path)

  val userDefinedCallback = parameters.loadedCallback
  parameters.loadedCallback = LoadedCallback { assetManager, fileName, type ->
    try {
      // If user defined a custom callback, we still want it to execute:
      userDefinedCallback?.finishedLoading(assetManager, fileName, type)
      result.complete(assetManager.get(assetDescriptor))
    } catch (exception: Throwable) {
      result.completeExceptionally(exception)
    }
  }
  load(assetDescriptor)
  return result
}

fun <T> getDefaultParametersForLoader(
  loader: AssetLoader<*, AssetLoaderParameters<*>>,
  path: String
): AssetLoaderParameters<T> = LoaderParametersSupplier[loader.javaClass, path]

private typealias ParametersSupplier<T> = (path: String) -> AssetLoaderParameters<T>

object LoaderParametersSupplier {
  private val loaderToParameters = mutableMapOf<Class<Loader<*>>, ParametersSupplier<*>>()

  init {
    this[TextureLoader::class.java] = { TextureLoader.TextureParameter() }
    // TODO Other types.
  }

  @Suppress("UNCHECKED_CAST")
  operator fun <T> get(type: Class<Loader<*>>, path: String): AssetLoaderParameters<T> {
    val supplier = loaderToParameters[type] ?: throw GdxRuntimeException("Unregistered loader type: $type")
    return supplier(path) as AssetLoaderParameters<T>
  }

  operator fun <T, L : Loader<T>> set(type: Class<L>, parametersSupplier: ParametersSupplier<T>) {
    @Suppress("UNCHECKED_CAST")
    loaderToParameters[type as Class<Loader<*>>] = parametersSupplier
  }
}

fun usageExample(assetManager: AssetManager) {
  KtxAsync.launch { 
    // Suspends until loaded:
    val texture = assetManager.loadAsync("logo.png", TextureParameter()).await()
    // Resumes when texture is ready to use.
  }
}