package com.narutohuo.xindazhou.share.ui

import android.content.Intent
import android.os.Bundle
import androidx.fragment.app.FragmentActivity
import com.narutohuo.xindazhou.core.log.ILog
import com.narutohuo.xindazhou.share.factory.ShareServiceFactory
import com.narutohuo.xindazhou.share.model.ShareContent
import com.narutohuo.xindazhou.share.model.ShareResponse

/**
 * 透明的代理 Activity，用于统一处理所有平台的分享回调
 * 
 * 这个 Activity 完全封装在分享组件内部，业务层不需要知道它的存在
 * 
 * 工作原理：
 * 1. 业务层调用 shareService.share()，自动启动这个透明的代理 Activity
 * 2. 代理 Activity 调用友盟 SDK 进行分享（或显示分享弹窗）
 * 3. 用户在第三方应用（微信、QQ、微博等）完成分享操作
 * 4. 第三方应用回调到各自的回调 Activity（WXEntryActivity、AuthActivity、WBShareTransActivity）
 * 5. 友盟 SDK 自动处理回调，通过 onActivityResult() 回到这个 Activity
 * 6. 处理结果后，通过回调传递给业务层
 * 7. 关闭透明 Activity，回到原来的界面
 * 
 * 关键点：
 * - ✅ 统一处理所有平台的回调（微信、QQ、微博等），业务层无需关心
 * - ✅ 业务层不需要在 Activity 中处理 onActivityResult，完全封装
 * - ✅ 透明主题，用户看不到，体验流畅
 */
class ShareProxyActivity : FragmentActivity() {
    
    companion object {
        private const val EXTRA_SHARE_CONTENT = "extra_share_content"
        private const val EXTRA_CALLBACK_ID = "extra_callback_id"
        
        // 存储回调的 Map（Activity 生命周期短，会在 onDestroy 中清理，无需 WeakReference）
        private val callbacks = mutableMapOf<String, (ShareResponse) -> Unit>()
        
        /**
         * 启动分享代理 Activity
         * 
         * @param activity 当前 Activity（可以是任何 Activity）
         * @param content 分享内容
         * @param callback 分享结果回调
         */
        fun startShare(
            activity: android.app.Activity,
            content: ShareContent,
            callback: (ShareResponse) -> Unit
        ) {
            val callbackId = System.currentTimeMillis().toString() + "_" + System.nanoTime()
            callbacks[callbackId] = callback
            
            val intent = Intent(activity, ShareProxyActivity::class.java).apply {
                putExtra(EXTRA_SHARE_CONTENT, content)
                putExtra(EXTRA_CALLBACK_ID, callbackId)
            }
            activity.startActivity(intent)
        }
        
        /**
         * 清理回调（防止内存泄漏）
         */
        fun clearCallback(callbackId: String) {
            callbacks.remove(callbackId)
        }
    }
    
    private lateinit var shareContent: ShareContent
    private lateinit var callbackId: String
    private var isShareCompleted = false
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // 设置为透明，用户看不到
        setTheme(android.R.style.Theme_Translucent_NoTitleBar)
        
        // 获取传递的数据
        shareContent = intent.getParcelableExtra(EXTRA_SHARE_CONTENT)
            ?: run {
                ILog.e("ShareProxyActivity", "onCreate: ShareContent 为空")
                finish()
                return
            }
        
        callbackId = intent.getStringExtra(EXTRA_CALLBACK_ID)
            ?: run {
                ILog.e("ShareProxyActivity", "onCreate: callbackId 为空")
                finish()
                return
            }
        
        ILog.d("ShareProxyActivity", "onCreate: 启动分享，callbackId=$callbackId")
        
        // 立即启动分享（使用 shareManual，避免递归调用 share()）
        val shareService = ShareServiceFactory.getInstance()
        // 注意：这里必须调用 shareManual，不能调用 share()，否则会无限递归
        shareService.shareManual(this, shareContent) { response ->
            // 分享完成，调用回调
            ILog.d("ShareProxyActivity", "share callback: success=${response.success}, platform=${response.data}, error=${response.errorMessage}")
            isShareCompleted = true
            
            // 取消超时任务
            timeoutHandler?.removeCallbacks(timeoutRunnable ?: return@shareManual)
            timeoutRunnable = null
            
            // 调用回调
            callbacks[callbackId]?.invoke(response)
            clearCallback(callbackId)
            
            // 立即关闭，不延迟（避免卡死）
            if (!isFinishing && !isDestroyed) {
                finish()
            }
        }
    }
    
    override fun onNewIntent(intent: Intent?) {
        super.onNewIntent(intent)
        // 处理微信/QQ/微博返回的情况（某些平台可能通过 onNewIntent 传递回调）
        ILog.d("ShareProxyActivity", "onNewIntent: 收到新的 Intent")
        setIntent(intent) // 更新 Intent，确保后续能获取到最新数据
        // 友盟 SDK 可能会通过 onNewIntent 传递回调，需要在这里处理
        intent?.let {
            val shareService = ShareServiceFactory.getInstance()
            shareService.onActivityResult(this, 0, 0, it) // requestCode, resultCode 不重要，友盟内部会处理
        }
    }
    
    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        
        ILog.d("ShareProxyActivity", "onActivityResult: requestCode=$requestCode, resultCode=$resultCode")
        
        // 处理友盟 SDK 的回调
        val shareService = ShareServiceFactory.getInstance()
        shareService.onActivityResult(this, requestCode, resultCode, data)
    }
    
    private var timeoutHandler: android.os.Handler? = null
    private var timeoutRunnable: Runnable? = null
    
    override fun onResume() {
        super.onResume()
        
        // 如果分享已完成，立即关闭
        if (isShareCompleted) {
            ILog.d("ShareProxyActivity", "onResume: 分享已完成，立即关闭")
            finish()
            return
        }
        
        // 增加超时保护：如果 3 秒后还没有回调，强制关闭
        // 注意：每次 onResume 都会重新计时，避免重复设置
        if (!isFinishing && !isDestroyed) {
            // 取消之前的超时任务
            timeoutHandler?.removeCallbacks(timeoutRunnable ?: return)
            
            timeoutHandler = android.os.Handler(android.os.Looper.getMainLooper())
            timeoutRunnable = Runnable {
                if (!isShareCompleted && !isFinishing && !isDestroyed) {
                    ILog.w("ShareProxyActivity", "onResume: 超时未收到回调，强制关闭并调用失败回调")
                    // 调用失败回调
                    if (::callbackId.isInitialized) {
                        callbacks[callbackId]?.invoke(
                            ShareResponse(
                                success = false,
                                errorMessage = "分享超时，请重试",
                                timestamp = System.currentTimeMillis()
                            )
                        )
                        clearCallback(callbackId)
                    }
                    finish()
                }
            }
            timeoutHandler?.postDelayed(timeoutRunnable!!, 3000) // 3 秒超时（缩短超时时间）
        }
    }
    
    override fun onPause() {
        super.onPause()
        // 取消超时任务，避免在后台时触发
        timeoutHandler?.removeCallbacks(timeoutRunnable ?: return)
        timeoutRunnable = null
    }
    
    override fun onDestroy() {
        super.onDestroy()
        
        // 取消超时任务
        timeoutHandler?.removeCallbacks(timeoutRunnable ?: return)
        timeoutHandler = null
        timeoutRunnable = null
        
        // 如果还没有调用回调，说明可能出现了异常，调用失败回调
        if (!isShareCompleted && ::callbackId.isInitialized) {
            ILog.w("ShareProxyActivity", "onDestroy: Activity 被销毁但未收到回调，调用失败回调")
            callbacks[callbackId]?.invoke(
                ShareResponse(
                    success = false,
                    errorMessage = "分享过程中断，请重试",
                    timestamp = System.currentTimeMillis()
                )
            )
            clearCallback(callbackId)
        }
        
        ILog.d("ShareProxyActivity", "onDestroy: Activity 已销毁")
    }
}

