private fun createPlayerViaReflection(activity: Activity): Any {
    // 1. Try Unity 6 class
    val clazz = try {
        Class.forName("com.unity3d.player.UnityPlayerForActivityOrService")
    } catch (_: ClassNotFoundException) {
        // 2. Fall back to legacy class
        Class.forName("com.unity3d.player.UnityPlayer")
    }

    // 3. Try multiple constructor signatures (most specific first)
    return tryConstructors(clazz, activity)
}

private fun tryConstructors(clazz: Class<*>, activity: Activity): Any {
    // Signature 1: Unity 6 with lifecycle events
    try {
        val lifecycleClass = Class.forName(
            "com.unity3d.player.IUnityPlayerLifecycleEvents"
        )
        return clazz.getConstructor(Context::class.java, lifecycleClass)
            .newInstance(activity, null)
    } catch (_: Exception) {}

    // Signature 2: Unity 6 with Context only
    try {
        return clazz.getConstructor(Context::class.java)
            .newInstance(activity)
    } catch (_: Exception) {}

    // Signature 3: Legacy with Activity
    try {
        return clazz.getConstructor(Activity::class.java)
            .newInstance(activity)
    } catch (_: Exception) {}

    throw IllegalStateException("No compatible Unity player constructor found")
}

private fun getEmbeddableView(player: Any): View {
    // Unity 6: use getFrameLayout()
    try {
        val frameLayout = player.javaClass
            .getMethod("getFrameLayout")
            .invoke(player) as? View
        if (frameLayout != null) return frameLayout
    } catch (_: Exception) {}

    // Additional fallback methods to try
    val fallbackMethods = listOf(
        "getView",
        "getPlayerView",
        "getSurfaceView",
        "getRootView",
    )
    for (methodName in fallbackMethods) {
        try {
            val view = player.javaClass
                .getMethod(methodName)
                .invoke(player) as? View
            if (view != null) return view
        } catch (_: Exception) { continue }
    }

    // Last resort: player itself if it is a View (legacy UnityPlayer)
    if (player is View) return player

    throw IllegalStateException("Cannot extract View from Unity player")
}

private fun activateRendering(player: Any, unityView: View) {
    // 1. Signal window focus to the player
    try {
        val focusResult = unityView.requestFocus()
        player.javaClass
            .getMethod("windowFocusChanged", Boolean::class.java)
            .invoke(player, focusResult)
    } catch (_: Exception) {}

    // 2. Pause then resume to unfreeze the rendering pipeline
    try {
        player.javaClass.getMethod("pause").invoke(player)
        player.javaClass.getMethod("resume").invoke(player)
    } catch (_: Exception) {}
}

class UnityContainerLayout(context: Context) : FrameLayout(context) {

    private var player: Any? = null

    fun setPlayer(player: Any) {
        this.player = player
    }

    override fun onWindowVisibilityChanged(visibility: Int) {
        super.onWindowVisibilityChanged(visibility)

        if (visibility == VISIBLE) {
            // When becoming visible again (after orientation change,
            // hot reload, or returning from background), restart
            // rendering to prevent UI freeze.
            player?.let { p ->
                try {
                    p.javaClass.getMethod("pause").invoke(p)
                    p.javaClass.getMethod("resume").invoke(p)
                } catch (_: Exception) {}
            }
        }
    }
}

override fun dispatchTouchEvent(event: MotionEvent): Boolean {
    // Flutter's Virtual Display sends events with deviceId = 0.
    // Unity's New Input System requires deviceId != 0 to register touch.
    // Copy the event with deviceId = -1 to make Unity recognize it.
    val fixedEvent = if (event.deviceId == 0) {
        MotionEvent.obtain(event).apply {
            try {
                val field = MotionEvent::class.java.getDeclaredField("mDeviceId")
                field.isAccessible = true
                field.setInt(this, -1)
            } catch (_: Exception) {
                // Fallback: use the event as-is
            }
        }
    } else {
        event
    }

    // Also ensure the event source is set correctly
    fixedEvent.source = InputDevice.SOURCE_TOUCHSCREEN

    return super.dispatchTouchEvent(fixedEvent)
}