package com.hikoncont.service

import android.accessibilityservice.AccessibilityService
import android.accessibilityservice.AccessibilityServiceInfo
import android.content.Context
import android.content.Intent
import android.graphics.Rect
import android.util.Log
import android.view.accessibility.AccessibilityEvent
import android.view.accessibility.AccessibilityNodeInfo
import android.view.accessibility.AccessibilityWindowInfo
import kotlinx.coroutines.*

/**
 * 多任务页面监听无障碍服务
 * 专门监听多任务页面，阻断点击事件并发送返回操作
 */
class RecentsMonitorService : AccessibilityService() {
    
    companion object {
        private const val TAG = "RecentsMonitorService"
        
        // 多任务页面相关包名和类名
        private val RECENTS_PACKAGES = listOf(
            "com.android.systemui",  // 系统UI
            "com.android.launcher3",  // 原生启动器
            "com.miui.home",         // MIUI启动器
            "com.huawei.android.launcher", // 华为启动器
            "com.oppo.launcher",     // OPPO启动器
            "com.vivo.launcher",     // Vivo启动器
            "com.oneplus.launcher",  // 一加启动器
            "com.samsung.android.launcher", // 三星启动器
            "com.meizu.flyme.launcher" // 魅族启动器
        )
        
        // 多任务页面相关关键词
        private val RECENTS_KEYWORDS = listOf(
            "最近任务", "多任务", "任务管理", "最近使用",
            "Recent", "Recents", "Task", "Tasks",
            "清除全部", "清除所有", "Clear all",
            "最近应用", "应用切换", "切换应用"
        )
        
        // 多任务页面相关类名
        private val RECENTS_CLASSES = listOf(
            "RecentsActivity", "TaskStackView", "RecentsView",
            "RecentTasksView", "TaskView", "RecentsPanelView",
            "RecentTasksPanel", "TaskPanel", "RecentsContainer"
        )
        
        @Volatile
        private var instance: RecentsMonitorService? = null
        
        fun getInstance(): RecentsMonitorService? = instance
        
        fun isServiceRunning(): Boolean = instance != null
    }
    
    // 协程作用域
    private val serviceScope = CoroutineScope(Dispatchers.Main + SupervisorJob())
    
    // 状态管理
    private var isInRecentsPage = false
    private var lastRecentsCheckTime = 0L
    private val RECENTS_CHECK_INTERVAL = 500L // 500ms检查间隔
    
    // 点击阻断相关
    private var lastClickTime = 0L
    private val CLICK_BLOCK_INTERVAL = 100L // 100ms内阻断重复点击
    
    override fun onCreate() {
        super.onCreate()
        Log.i(TAG, "🚀 多任务页面监听服务创建")
        instance = this
    }
    
    override fun onServiceConnected() {
        super.onServiceConnected()
        Log.i(TAG, "🔗 多任务页面监听服务已连接")
        
        // 配置服务信息
        val info = AccessibilityServiceInfo().apply {
            eventTypes = AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED or
                       AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED or
                       AccessibilityEvent.TYPE_VIEW_CLICKED or
                       AccessibilityEvent.TYPE_VIEW_FOCUSED
            feedbackType = AccessibilityServiceInfo.FEEDBACK_GENERIC
            flags = AccessibilityServiceInfo.FLAG_RETRIEVE_INTERACTIVE_WINDOWS or
                   AccessibilityServiceInfo.FLAG_REPORT_VIEW_IDS or
                   AccessibilityServiceInfo.FLAG_REQUEST_FILTER_KEY_EVENTS
            notificationTimeout = 0
        }
        this.serviceInfo = info
        
        Log.i(TAG, "✅ 多任务页面监听服务配置完成")
    }
    
    override fun onAccessibilityEvent(event: AccessibilityEvent?) {
        if (event == null) return
        
        try {
            when (event.eventType) {
                AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED -> {
                    handleWindowStateChanged(event)
                }
                AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED -> {
                    handleWindowContentChanged(event)
                }
                AccessibilityEvent.TYPE_VIEW_CLICKED -> {
                    handleViewClicked(event)
                }
                AccessibilityEvent.TYPE_VIEW_FOCUSED -> {
                    handleViewFocused(event)
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 处理无障碍事件失败", e)
        }
    }
    
    override fun onInterrupt() {
        Log.w(TAG, "⚠️ 多任务页面监听服务被中断")
    }
    
    override fun onDestroy() {
        super.onDestroy()
        Log.i(TAG, "🛑 多任务页面监听服务销毁")
        instance = null
        serviceScope.cancel()
    }
    
    /**
     * 处理窗口状态变化事件
     */
    private fun handleWindowStateChanged(event: AccessibilityEvent) {
        val packageName = event.packageName?.toString() ?: ""
        val className = event.className?.toString() ?: ""
        
        Log.d(TAG, "🪟 窗口状态变化: $packageName/$className")
        
        // 检查是否是多任务页面
        val isRecents = isRecentsPage(packageName, className, event)
        
        if (isRecents != isInRecentsPage) {
            isInRecentsPage = isRecents
            if (isInRecentsPage) {
                Log.i(TAG, "📱 进入多任务页面")
                onEnterRecentsPage()
            } else {
                Log.i(TAG, "📱 离开多任务页面")
                onExitRecentsPage()
            }
        }
    }
    
    /**
     * 处理窗口内容变化事件
     */
    private fun handleWindowContentChanged(event: AccessibilityEvent) {
        if (!isInRecentsPage) return
        
        val currentTime = System.currentTimeMillis()
        if (currentTime - lastRecentsCheckTime < RECENTS_CHECK_INTERVAL) {
            return
        }
        lastRecentsCheckTime = currentTime
        
        // 重新检查是否还在多任务页面
        val packageName = event.packageName?.toString() ?: ""
        val className = event.className?.toString() ?: ""
        val isRecents = isRecentsPage(packageName, className, event)
        
        if (!isRecents && isInRecentsPage) {
            Log.i(TAG, "📱 检测到离开多任务页面")
            isInRecentsPage = false
            onExitRecentsPage()
        }
    }
    
    /**
     * 处理视图点击事件
     */
    private fun handleViewClicked(event: AccessibilityEvent) {
        if (!isInRecentsPage) return
        
        val currentTime = System.currentTimeMillis()
        if (currentTime - lastClickTime < CLICK_BLOCK_INTERVAL) {
            Log.d(TAG, "🚫 阻断重复点击事件")
            return
        }
        lastClickTime = currentTime
        
        Log.i(TAG, "🚫 在多任务页面检测到点击事件，准备阻断并发送返回")
        
        // 阻断点击事件（通过不处理来实现）
        // 然后发送返回操作
        serviceScope.launch {
            delay(50) // 短暂延迟确保点击事件被阻断
            sendBackAction()
        }
    }
    
    /**
     * 处理视图焦点事件
     */
    private fun handleViewFocused(event: AccessibilityEvent) {
        if (!isInRecentsPage) return
        
        Log.d(TAG, "🎯 在多任务页面检测到焦点事件")
    }
    
    /**
     * 检查是否是多任务页面
     */
    private fun isRecentsPage(packageName: String, className: String, event: AccessibilityEvent): Boolean {
        // 1. 检查包名
        if (RECENTS_PACKAGES.any { packageName.contains(it, true) }) {
            Log.d(TAG, "🔍 包名匹配多任务页面: $packageName")
            return true
        }
        
        // 2. 检查类名
        if (RECENTS_CLASSES.any { className.contains(it, true) }) {
            Log.d(TAG, "🔍 类名匹配多任务页面: $className")
            return true
        }
        
        // 3. 检查窗口内容
        val rootNode = rootInActiveWindow
        if (rootNode != null) {
            val isRecentsByContent = checkRecentsByContent(rootNode)
            if (isRecentsByContent) {
                Log.d(TAG, "🔍 内容匹配多任务页面")
                return true
            }
        }
        
        // 4. 检查窗口信息
        val windows = windows
        if (windows != null) {
            for (window in windows) {
                if (isRecentsWindow(window)) {
                    Log.d(TAG, "🔍 窗口信息匹配多任务页面")
                    return true
                }
            }
        }
        
        return false
    }
    
    /**
     * 通过内容检查是否是多任务页面
     */
    private fun checkRecentsByContent(rootNode: AccessibilityNodeInfo): Boolean {
        return try {
            val texts = collectAllTexts(rootNode)
            val matchCount = RECENTS_KEYWORDS.count { keyword ->
                texts.any { text -> text.contains(keyword, true) }
            }
            
            Log.d(TAG, "🔍 内容检查: 匹配关键词 $matchCount/${RECENTS_KEYWORDS.size}")
            Log.d(TAG, "🔍 页面文本: ${texts.take(10).joinToString(", ")}")
            
            // 如果有2个或以上关键词匹配，认为是多任务页面
            matchCount >= 2
        } catch (e: Exception) {
            Log.e(TAG, "❌ 内容检查失败", e)
            false
        }
    }
    
    /**
     * 检查窗口是否是多任务窗口
     */
    private fun isRecentsWindow(window: AccessibilityWindowInfo): Boolean {
        return try {
            val type = window.type
            val title = window.title?.toString() ?: ""
            
            Log.d(TAG, "🔍 窗口检查: type=$type, title='$title'")
            
            // 检查窗口类型和标题
            when (type) {
                AccessibilityWindowInfo.TYPE_SYSTEM -> {
                    // 系统对话框可能是多任务页面
                    RECENTS_KEYWORDS.any { title.contains(it, true) }
                }
                AccessibilityWindowInfo.TYPE_APPLICATION -> {
                    // 应用窗口检查包名
                    val packageName = window.root?.packageName?.toString() ?: ""
                    RECENTS_PACKAGES.any { packageName.contains(it, true) }
                }
                else -> false
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ 窗口检查失败", e)
            false
        }
    }
    
    /**
     * 收集所有文本内容
     */
    private fun collectAllTexts(node: AccessibilityNodeInfo): List<String> {
        val texts = mutableListOf<String>()
        
        try {
            // 添加节点文本
            node.text?.toString()?.let { texts.add(it) }
            node.contentDescription?.toString()?.let { texts.add(it) }
            
            // 递归收集子节点文本
            for (i in 0 until node.childCount) {
                val child = node.getChild(i)
                if (child != null) {
                    texts.addAll(collectAllTexts(child))
                    child.recycle()
                }
            }
        } catch (e: Exception) {
            Log.w(TAG, "⚠️ 收集文本失败", e)
        }
        
        return texts.filter { it.isNotBlank() }
    }
    
    /**
     * 进入多任务页面时的处理
     */
    private fun onEnterRecentsPage() {
        Log.i(TAG, "📱 进入多任务页面，开始监听点击事件")
        
        // 可以在这里添加额外的处理逻辑
        // 比如发送广播通知其他组件
        val intent = Intent("android.mycustrecev.RECENTS_PAGE_ENTERED")
        sendBroadcast(intent)
    }
    
    /**
     * 离开多任务页面时的处理
     */
    private fun onExitRecentsPage() {
        Log.i(TAG, "📱 离开多任务页面，停止监听点击事件")
        
        // 可以在这里添加额外的处理逻辑
        // 比如发送广播通知其他组件
        val intent = Intent("android.mycustrecev.RECENTS_PAGE_EXITED")
        sendBroadcast(intent)
    }
    
    /**
     * 发送返回操作
     */
    private suspend fun sendBackAction() {
        try {
            Log.i(TAG, "🔙 发送返回操作")
            
            // 方法1: 使用performGlobalAction
            val success = performGlobalAction(GLOBAL_ACTION_BACK)
            
            if (success) {
                Log.i(TAG, "✅ 返回操作发送成功")
            } else {
                Log.w(TAG, "⚠️ 返回操作发送失败，尝试其他方法")
                
                // 方法2: 使用KeyEvent (需要额外权限)
                // sendBackKeyEvent()
                
                // 方法3: 使用Intent (备用方案)
                // sendBackIntent()
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 发送返回操作失败", e)
        }
    }
    
    /**
     * 发送返回键事件 (备用方法)
     */
    private fun sendBackKeyEvent() {
        try {
            Log.d(TAG, "🔙 尝试发送返回键事件")
            
            // 这里需要额外的权限和实现
            // 暂时不实现，因为performGlobalAction通常就足够了
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 发送返回键事件失败", e)
        }
    }
    
    /**
     * 发送返回Intent (备用方法)
     */
    private fun sendBackIntent() {
        try {
            Log.d(TAG, "🔙 尝试发送返回Intent")
            
            // 这里可以发送特定的Intent来触发返回操作
            // 但通常performGlobalAction就足够了
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 发送返回Intent失败", e)
        }
    }
}
