#FFM

import kotlinx.coroutines.delay
import okio.utf8Size
import org.bytedeco.opencv.global.opencv_core.CV_8UC4
import org.bytedeco.opencv.global.opencv_core.flip
import org.bytedeco.opencv.global.opencv_highgui.*
import org.bytedeco.opencv.global.opencv_imgproc.COLOR_RGBA2BGRA
import org.bytedeco.opencv.global.opencv_imgproc.cvtColor
import org.bytedeco.opencv.opencv_core.Mat
import java.lang.foreign.*

suspend fun main() {
    MuMu("""E:\softwares\MuMu Player 12""").use { player ->
        val initialized = player.initialize()
        if (!initialized) return

        var lastUpdateTime = System.nanoTime()
        val frameInterval = 1_000_000_000L / 30 // 30 FPS
        val mat = Mat()
        delay(300)
        while (true) {
            when (waitKey(1)) {
                27 -> {
                    destroyAllWindows()
                    return
                }

                32 -> {
                    player.click(400, 120)
                    delay(300)
                    player.inputText("你好啊🎉")
                    delay(300)
                    // 数字 1
                    player.inputKey(2)
                    delay(300)
                    // 数字 2
                    player.inputKey(3)
                }

                else -> {
                    val currentTime = System.nanoTime()
                    if (currentTime - lastUpdateTime >= frameInterval) {
                        player.capture(mat)

                        imshow("截屏", mat)

                        lastUpdateTime = currentTime
                    }
                }
            }
        }
    }
}

class MuMu(val path: String, val index: Int = 0) : AutoCloseable {
    // 模拟器的句柄
    private var handle = 0

    // 模拟器显示 ID。安卓屏幕号，如果没有开启模拟器保活功能，永远为0
    private var displayId = -1

    // 模拟器分辨率 宽高指针
    val widthPointer: MemorySegment = Arena.ofAuto().allocate(ValueLayout.JAVA_INT)
    val heightPointer: MemorySegment = Arena.ofAuto().allocate(ValueLayout.JAVA_INT)

    fun initialize(packageName: String = "default"): Boolean = synchronized(this) {
        val handle = connect(path, index)
        if (handle == 0) {
            println("初始化失败：连接 $path 位置，编号为 $index 的模拟器失败！")
            return false
        }
        println("连接 $path 位置，编号为 $index 的模拟器成功，句柄编号：$handle")


        val displayId = getDisplayId(handle, packageName)
        if (displayId < 0) {
            println("初始化失败：获取模拟器显示 ID 失败！")
            return false
        }
        println("模拟器显示 ID：$displayId")

        captureDisplayHandle.invoke(handle, displayId, 0, widthPointer, heightPointer, MemorySegment.NULL)
        val width = widthPointer.get(ValueLayout.JAVA_INT, 0)
        val height = heightPointer.get(ValueLayout.JAVA_INT, 0)
        if (width <= 0 || height <= 0) {
            println("获初始化失败：取模拟器分辨率失败！")
            return false
        }
        println("模拟器分辨率为宽：${width}，高：${height}")

        this.handle = handle
        this.displayId = displayId

        println("初始化成功🎉")
        return true
    }

    fun capture(mat: Mat): Boolean {
        val width = widthPointer.get(ValueLayout.JAVA_INT, 0)
        val height = heightPointer.get(ValueLayout.JAVA_INT, 0)
        val byteBufferSize = width * height * 4
        if (byteBufferSize <= 0) return false

        mat.create(height, width, CV_8UC4)

        val result = captureDisplayHandle.invoke(
            handle,
            displayId,
            byteBufferSize,
            widthPointer,
            heightPointer,
            MemorySegment.ofAddress(mat.data().address())
        )
        cvtColor(mat, mat, COLOR_RGBA2BGRA)
        flip(mat, mat, 0)
        // 返回值 0 表示截屏成功
        return result == 0
    }

    // 设置要截屏的包名
    fun setPackage(name: String = "default", appIndex: Int = 0): Boolean {
        val displayId = getDisplayId(handle, name, appIndex)
        val result = displayId >= 0
        if (result) {
            this.displayId = displayId
        }
        println("设置显示 $name 的 $appIndex 号进程${if (result) "成功" else "失败！"}")
        return result
    }

    private fun connect(path: String, index: Int): Int {
        val connectHandle = linker.downcallHandle(
            symbolLookup.find("nemu_connect").get(),
            FunctionDescriptor.of(
                // 返回值 handle，int 类型，0 表示失败，但非 0 并不表示成功
                ValueLayout.JAVA_INT,
                // 模拟器路径，字符串
                ValueLayout.ADDRESS,
                // 要连接的模拟器索引号，int
                ValueLayout.JAVA_INT
            )
        )
        return Arena.ofConfined().use { arena ->
            connectHandle.invoke(arena.allocateArray(ValueLayout.JAVA_CHAR, *path.toCharArray()), index) as Int
        }
    }

    // appIndex 为应用分身的序号，默认为 0
    private fun getDisplayId(handle: Int, packageName: String, appIndex: Int = 0): Int {
        val getDisplayIdHandle = linker.downcallHandle(
            symbolLookup.find("nemu_get_display_id").get(),
            FunctionDescriptor.of(
                // 返回值类型 int
                ValueLayout.JAVA_INT,
                // 模拟器的 handle，int
                ValueLayout.JAVA_INT,
                // 包名，字符串
                ValueLayout.ADDRESS,
                // 要获取的进程索引号，int
                ValueLayout.JAVA_INT,
            )
        )
        return Arena.ofConfined().use { arena ->
            getDisplayIdHandle.invoke(
                handle,
                arena.allocateUtf8String(packageName),
                appIndex
            ) as Int
        }
    }

    private fun touchDown(x: Int, y: Int): Int = touchDownHandle.invoke(handle, displayId, x, y) as Int

    private fun touchUp() = touchUpHandle.invoke(handle, displayId) as Int

    private fun keyDown(keyCode: Int): Int = keyDownHandle.invoke(handle, displayId, keyCode) as Int

    private fun keyUp(keyCode: Int): Int = keyUpHandle.invoke(handle, displayId, keyCode) as Int


    fun click(x: Int, y: Int): Boolean {
        val down = touchDown(x, y)
        val up = touchUp()
        return down == 0 && up == 0
    }

    suspend fun longClick(x: Int, y: Int, delayMilliseconds: Long = 500L): Boolean {
        val down = touchDown(x, y)
        delay(delayMilliseconds)
        val up = touchUp()
        return down == 0 && up == 0
    }


    // keyCode 见 https://github.com/torvalds/linux/blob/master/include/uapi/linux/input-event-codes.h
    fun inputKey(keyCode: Int): Boolean {
        val down = keyDown(keyCode)
        val up = keyUp(keyCode)
        return down == 0 && up == 0
    }

    fun inputText(text: String): Boolean = Arena.ofConfined().use { arena ->
        inputTextHandle.invoke(handle, text.utf8Size().toInt(), arena.allocateUtf8String(text)) as Int == 0
    }

    suspend fun swipe(x1: Int, y1: Int, x2: Int, y2: Int, duration: Long = 500L, steps: Int = 20) {
        val xStep = (x2 - x1) / steps.toFloat()
        val yStep = (y2 - y1) / steps.toFloat()
        val stepDelay = duration / steps

        repeat(steps) {
            val currentX = (x1 + xStep * it).roundToInt()
            val currentY = (y1 + yStep * it).roundToInt()
            touchDown(currentX, currentY)
            delay(stepDelay)
        }

        touchDown(x2, y2)
        touchUp()
    }


    override fun close() {
        if (handle != 0) {
            linker.downcallHandle(
                symbolLookup.find("nemu_disconnect").get(),
                // 无返回值，参数为 模拟器的 handle，int 类型
                FunctionDescriptor.ofVoid(ValueLayout.JAVA_INT)
            ).invoke(handle)
        }
    }

    companion object {
        private val symbolLookup = SymbolLookup.libraryLookup(
            """lib/external_renderer_ipc""",
            Arena.ofAuto()
        )
        private val linker = Linker.nativeLinker()

        private val captureDisplayHandle = linker.downcallHandle(
            symbolLookup.find("nemu_capture_display").get(),
            FunctionDescriptor.of(
                // 返回值类型 int，0 代表截图成功，非 0 代表截图失败
                ValueLayout.JAVA_INT,
                // 模拟器的 handle（句柄，代表是哪个模拟器），int
                ValueLayout.JAVA_INT,
                // display id（一个模拟器可以有多个Windows窗口，这个参数代表是哪个窗口），int
                ValueLayout.JAVA_INT,
                // 截图字节数，等于 宽*高*4
                ValueLayout.JAVA_INT,
                // 宽，int 类型的指针
                ValueLayout.ADDRESS,
                // 高，int 类型的指针
                ValueLayout.ADDRESS,
                // 截图数据，指针，用 ByteBuffer 类型
                ValueLayout.ADDRESS
            )
        )

        private val touchDownHandle = linker.downcallHandle(
            symbolLookup.find("nemu_input_event_touch_down").get(),
            FunctionDescriptor.of(
                // 返回值类型 int，0 代表成功，非 0 代表失败
                ValueLayout.JAVA_INT,
                // 模拟器的 handle（句柄，代表是哪个模拟器），int
                ValueLayout.JAVA_INT,
                // display id（一个模拟器可以有多个Windows窗口，这个参数代表是哪个窗口），int
                ValueLayout.JAVA_INT,
                // x，int
                ValueLayout.JAVA_INT,
                // y，int
                ValueLayout.JAVA_INT,
            )
        )

        private val touchUpHandle = linker.downcallHandle(
            symbolLookup.find("nemu_input_event_touch_up").get(),
            FunctionDescriptor.of(
                // 返回值类型 int，0 代表成功，非 0 代表失败
                ValueLayout.JAVA_INT,
                // 模拟器的 handle（句柄，代表是哪个模拟器），int
                ValueLayout.JAVA_INT,
                // display id（一个模拟器可以有多个Windows窗口，这个参数代表是哪个窗口），int
                ValueLayout.JAVA_INT,
            )
        )

        private val keyDownHandle = linker.downcallHandle(
            symbolLookup.find("nemu_input_event_key_down").get(),
            FunctionDescriptor.of(
                // 返回值类型 int，0 代表成功，非 0 代表失败
                ValueLayout.JAVA_INT,
                // 模拟器的 handle（句柄，代表是哪个模拟器），int
                ValueLayout.JAVA_INT,
                // display id（一个模拟器可以有多个Windows窗口，这个参数代表是哪个窗口），int
                ValueLayout.JAVA_INT,
                // keycode，int
                ValueLayout.JAVA_INT,
            )
        )

        private val keyUpHandle = linker.downcallHandle(
            symbolLookup.find("nemu_input_event_key_up").get(),
            FunctionDescriptor.of(
                // 返回值类型 int，0 代表成功，非 0 代表失败
                ValueLayout.JAVA_INT,
                // 模拟器的 handle（句柄，代表是哪个模拟器），int
                ValueLayout.JAVA_INT,
                // display id（一个模拟器可以有多个Windows窗口，这个参数代表是哪个窗口），int
                ValueLayout.JAVA_INT,
                // keycode，int
                ValueLayout.JAVA_INT,
            )
        )

        private val inputTextHandle = linker.downcallHandle(
            symbolLookup.find("nemu_input_text").get(),
            FunctionDescriptor.of(
                // 返回值类型 int，0 代表成功，非 0 代表失败
                ValueLayout.JAVA_INT,
                // 模拟器的 handle（句柄，代表是哪个模拟器），int
                ValueLayout.JAVA_INT,
                // text 的 utf8 长度，int
                ValueLayout.JAVA_INT,
                // text，要输入的文本，utf8 格式
                ValueLayout.ADDRESS,
            )
        )
    }
}