package uts.sdk.modules.tbDouyinPay

import android.app.Activity
import android.os.Handler
import android.os.Looper
import io.dcloud.uts.UTSAndroid
import org.json.JSONObject
import java.lang.reflect.Proxy

object TbDouyinPayNative {
    private val main = Handler(Looper.getMainLooper())
    private const val DYPAY_CLASS_NAME = "com.ss.android.dypay.api.DyPay"
    private const val CALLBACK_CLASS_NAME = "com.ss.android.dypay.api.IDyPayResultCallback"

    private fun getDyPayClass(): Class<*>? {
        return try {
            Class.forName(DYPAY_CLASS_NAME)
        } catch (_: Throwable) {
            null
        }
    }

    fun initialize(appId: String) {
        try {
            val clazz = getDyPayClass() ?: return
            val method = clazz.methods.firstOrNull { it.name == "setAppId" && it.parameterTypes.size == 1 }
            method?.invoke(null, appId)
        } catch (_: Throwable) {
        }
    }

    fun available(): Boolean {
        val activity = UTSAndroid.getUniActivity() ?: return false
        try {
            val clazz = getDyPayClass()
            if (clazz != null) {
                val method = clazz.methods.firstOrNull { it.name == "isDypayAppUsable" && it.parameterTypes.size == 1 }
                if (method != null) {
                    val res = method.invoke(null, activity)
                    if (res is Boolean) return res
                }
            }
        } catch (_: Throwable) {
        }

        return try {
            val pm = activity.packageManager
            pm.getPackageInfo("com.ss.android.ugc.aweme", 0)
            true
        } catch (_: Throwable) {
            try {
                val pm = activity.packageManager
                pm.getPackageInfo("com.ss.android.ugc.aweme.lite", 0)
                true
            } catch (_: Throwable) {
                false
            }
        }
    }

    fun pay(payload: String, loading: Boolean, done: (String) -> Unit) {
        main.post {
            val activity = UTSAndroid.getUniActivity()
            if (activity == null || activity.isFinishing) {
                done("""{"resultCode":"2","errorMsg":"当前页面不可用"}""")
                return@post
            }
            try {
                val dyPayClass = getDyPayClass()
                if (dyPayClass == null) {
                    done("""{"resultCode":"2","errorMsg":"支付 SDK 调用异常，请查询订单"}""")
                    return@post
                }

                val isUsableMethod = dyPayClass.methods.firstOrNull { it.name == "isDypayAppUsable" && it.parameterTypes.size == 1 }
                val isUsable = (isUsableMethod?.invoke(null, activity) as? Boolean) ?: false
                if (!isUsable) {
                    done("""{"resultCode":"100","errorMsg":"请安装或升级抖音客户端"}""")
                    return@post
                }

                val json = JSONObject(payload)
                val data = HashMap<String, String>()
                for (key in listOf("appid", "partnerid", "prepayid", "package", "noncestr", "timestamp", "sign")) {
                    if (json.has(key)) {
                        data[key] = json.getString(key)
                    }
                }

                val callbackClass = try {
                    Class.forName(CALLBACK_CLASS_NAME)
                } catch (_: Throwable) {
                    null
                }

                if (callbackClass == null) {
                    done("""{"resultCode":"2","errorMsg":"支付 SDK 调用异常，请查询订单"}""")
                    return@post
                }

                val callbackProxy = Proxy.newProxyInstance(
                    callbackClass.classLoader ?: activity.classLoader,
                    arrayOf(callbackClass)
                ) { _, method, args ->
                    if (method.name == "onResult" && args != null && args.isNotEmpty()) {
                        @Suppress("UNCHECKED_CAST")
                        val result = args[0] as? Map<String, Any?>
                        val resultCode = result?.get("resultCode")?.toString() ?: "3"
                        val errorMsg = result?.get("errorMsg")?.toString() ?: ""
                        val response = JSONObject()
                            .put("resultCode", resultCode)
                            .put("errorMsg", errorMsg)
                        main.post { done(response.toString()) }
                    }
                    null
                }

                val constructor = dyPayClass.constructors.firstOrNull {
                    it.parameterTypes.size == 1 && Activity::class.java.isAssignableFrom(it.parameterTypes[0])
                } ?: dyPayClass.getConstructor(Activity::class.java)

                val dyPayInstance = constructor.newInstance(activity)

                val payMethod = dyPayClass.methods.firstOrNull {
                    it.name == "pay" && it.parameterTypes.size == 3
                } ?: dyPayClass.methods.firstOrNull {
                    it.name == "pay" && it.parameterTypes.size == 2
                }

                if (payMethod == null) {
                    done("""{"resultCode":"2","errorMsg":"支付 SDK 调用异常，请查询订单"}""")
                    return@post
                }

                if (payMethod.parameterTypes.size == 3) {
                    payMethod.invoke(dyPayInstance, data, callbackProxy, loading)
                } else {
                    payMethod.invoke(dyPayInstance, data, callbackProxy)
                }
            } catch (_: Throwable) {
                done("""{"resultCode":"2","errorMsg":"支付 SDK 调用异常，请查询订单"}""")
            }
        }
    }
}