class CustomFactory : ViewModelProvider.Factory {
  override fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T {
    return when (modelClass) {
      HomeViewModel::class -> {
        // extras에서 Application 객체 가져오기
        val application = checkNotNull(extras[ViewModelProvider.AndroidViewModelFactory.APPLICATION_KEY])
        // HomeViewModel에 직접 전달
        HomeViewModel(application)
      }
      DetailViewModel::class -> {
        // extras에서 ViewModel에 전달할 SavedStateHandle 생성
        val savedStateHandle = extras.createSavedStateHandle()
        DetailViewModel(savedStateHandle)
      }
      else -> throw IllegalArgumentException("Unknown class $modelClass")
    } as T
  }
}

public open class ViewModelProvider {
  // ...  
  /**
   * Implementations of `Factory` interface are responsible to instantiate ViewModels.
   */
  public interface Factory {
    public fun <T : ViewModel> create(modelClass: Class<T>): T {
      throw UnsupportedOperationException(
          "Factory.create(String) is unsupported.  This Factory requires " +
          "`CreationExtras` to be passed into `create` method."
      )
    }

    public fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T =
      create(modelClass)
    }
  // ...
}

@MainThread
public inline fun <reified VM : ViewModel> ComponentActivity.viewModels(
  noinline extrasProducer: (() -> CreationExtras)? = null,
  noinline factoryProducer: (() -> Factory)? = null
): Lazy<VM> {
  val factoryPromise = factoryProducer ?: {
    defaultViewModelProviderFactory
  }

  return ViewModelLazy(
    VM::class,
    { viewModelStore },
    factoryPromise,
    { extrasProducer?.invoke() ?: this.defaultViewModelCreationExtras }
  )
}

public sealed class CreationExtras {
  internal val map: MutableMap<Key<*>, Any?> = mutableMapOf()

  public interface Key<T>

  public abstract operator fun <T> get(key: Key<T>): T?

  object Empty : CreationExtras() {
    override fun <T> get(key: Key<T>): T? = null
  }
}

public class MutableCreationExtras(initialExtras: CreationExtras = Empty) : CreationExtras() {
  init {
    vmap.putAll(initialExtras.map)
  }
  
  public operator fun <T> set(key: Key<T>, t: T) {
    map[key] = t
  }

  public override fun <T> get(key: Key<T>): T? {
    @Suppress("UNCHECKED_CAST")
    return map[key] as T?
  }
}

@MainThread
public fun CreationExtras.createSavedStateHandle(): SavedStateHandle {
  val savedStateRegistryOwner = this[SAVED_STATE_REGISTRY_OWNER_KEY]
    ?: throw IllegalArgumentException(
      "CreationExtras must have a value by `SAVED_STATE_REGISTRY_OWNER_KEY`"
    )
  val viewModelStateRegistryOwner = this[VIEW_MODEL_STORE_OWNER_KEY]
    ?: throw IllegalArgumentException(
      "CreationExtras must have a value by `VIEW_MODEL_STORE_OWNER_KEY`"
    )

  val defaultArgs = this[DEFAULT_ARGS_KEY]
  val key = this[VIEW_MODEL_KEY] ?: throw IllegalArgumentException(
    "CreationExtras must have a value by `VIEW_MODEL_KEY`"
  )
  return createSavedStateHandle(
    savedStateRegistryOwner, viewModelStateRegistryOwner, key, defaultArgs
  )
}

private fun createSavedStateHandle(
  savedStateRegistryOwner: SavedStateRegistryOwner,
  viewModelStoreOwner: ViewModelStoreOwner,
  key: String,
  defaultArgs: Bundle?
): SavedStateHandle {
  val vm = viewModelStoreOwner.savedStateHandlesVM
  val savedStateRegistry = savedStateRegistryOwner.savedStateRegistry

  // restoredState와 defaultState Bundle로 SavedStateHandle를 생성
  val handle = SavedStateHandle.createHandle(
    savedStateRegistry.consumeRestoredStateForKey(key), defaultArgs
  )
  val controller = SavedStateHandleController(key, handle)
  controller.attachToLifecycle(savedStateRegistry, savedStateRegistryOwner.lifecycle)
  vm.controllers.add(controller)

  return handle
}

// 생성할 ViewModel의 ViewModelStoreOwner에 해당하는 SavedStateRegistryOwner의 키
@JvmField
val SAVED_STATE_REGISTRY_OWNER_KEY = object : CreationExtras.Key<SavedStateRegistryOwner> {}

// 생성할 ViewModel의 Owner인 ViewModelStoreOwner의 키
@JvmField
val VIEW_MODEL_STORE_OWNER_KEY = object : CreationExtras.Key<ViewModelStoreOwner> {}

// 필요한 경우 SavedStateHandle에 전달되어야 하는 기본 값에 대한 키
@JvmField
val DEFAULT_ARGS_KEY = object : CreationExtras.Key<Bundle> {}

///////////////////////////////////////////////////////////////////////////
// Activity
///////////////////////////////////////////////////////////////////////////
class MainActivity : AppCompatActivity() {
  // CreationExtras Key
  private val testExtraKey = object : CreationExtras.Key<Int> {}

  override fun onCreate(savedInstanceState: Bundle?) {
    // ...
    // Create, ViewModelProvider.Factory
    val factory = object : ViewModelProvider.Factory {
      @Suppress("UNCHECKED_CAST")
      override fun <T : ViewModel> create(modelClass: Class<T>, extras: CreationExtras): T {
        // Convert, SavedStateHandle
        val savedStateHandle = extras.createSavedStateHandle()
        // CreationExtras.Key로 정의한 값을 추출 (기본값 -1)
        val id = extras[testExtraKey] ?: -1
        return MainViewModel(
          savedStateHandle = savedStateHandle,
          id = id
        ) as T
      }
    }

    // Create, ViewModel
    val viewModel: MainViewModel by viewModels(
      extrasProducer = {
        MutableCreationExtras(defaultViewModelCreationExtras).apply {
          // CreationExtras Key에 1234 값 반영
          set(testExtraKey, 1234)
          // MainViewModel 생성시 기본 데이터 반영
          set(DEFAULT_ARGS_KEY, bundleOf("self_extra_key" to "test"))
        }
      },
      factoryProducer = { factory }
    )
    viewModel.toString()
  }
}

///////////////////////////////////////////////////////////////////////////
// ViewModel
///////////////////////////////////////////////////////////////////////////
class MainViewModel(
    private val savedStateHandle: SavedStateHandle,
    private val id: Int
) : ViewModel() {
    init {
        logcat {
            "savedStateHandle = (" + savedStateHandle.keys()
                .joinToString(separator = ", ") {
                    "${it}:${savedStateHandle.get<Any>(it)}"
                } + ")"
        }
        logcat { "id = $id" }
    }
}