package com.narutohuo.xindazhou.core.log.impl

import android.content.Context
import android.util.Log
import com.narutohuo.xindazhou.core.log.ILogger
import com.narutohuo.xindazhou.core.log.LogLevel
import com.weijiaxing.logviewer.LogcatActivity

/**
 * LogcatViewer 日志实现
 * 
 * 使用 Android Log 输出日志，LogcatViewer 会自动捕获 logcat 输出并显示在浮动窗口中
 * 
 * 使用方式：
 * ```kotlin
 * // 在 Application 中初始化
 * ILog.init(LogcatViewerLog.getInstance())
 * 
 * // 启动 LogcatViewer 浮动窗口（在需要的地方调用）
 * LogcatActivity.launch(context)
 * ```
 * 
 * 注意：
 * - LogcatViewer 会自动捕获 logcat 输出，无需额外配置
 * - 日志会同时输出到 logcat 和 LogcatViewer 浮动窗口
 * - 可以通过 LogcatActivity.launch() 启动/关闭浮动窗口
 */
class LogcatViewerLog private constructor() : ILogger {
    
    companion object {
        @Volatile
        private var INSTANCE: LogcatViewerLog? = null
        
        @Volatile
        private var lifecycleCallback: android.app.Application.ActivityLifecycleCallbacks? = null
        
        /**
         * 获取单例实例
         */
        @JvmStatic
        fun getInstance(): ILogger {
            return INSTANCE ?: synchronized(this) {
                INSTANCE ?: LogcatViewerLog().also { INSTANCE = it }
            }
        }
        
        /**
         * 注册 ActivityLifecycleCallbacks，自动在第一个 Activity resume 时启动 LogcatViewer
         */
        @JvmStatic
        fun registerActivityLifecycle(application: android.app.Application) {
            if (lifecycleCallback != null) {
                // 已经注册过了，不重复注册
                return
            }
            
            lifecycleCallback = object : android.app.Application.ActivityLifecycleCallbacks {
                @Volatile
                private var hasLaunched = false
                @Volatile
                private var isWaitingForPermission = false
                
                override fun onActivityResumed(activity: android.app.Activity) {
                    // 如果正在等待权限授予，检查权限状态
                    if (isWaitingForPermission) {
                        val hasPermission = if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
                            android.provider.Settings.canDrawOverlays(activity)
                        } else {
                            true
                        }
                        
                        if (hasPermission) {
                            android.util.Log.d("LogcatViewerLog", "检测到权限已授予，重新启动 LogcatViewer")
                            isWaitingForPermission = false
                            // 延迟启动，避免全屏模式影响
                            activity.window.decorView.postDelayed({
                                INSTANCE?.launchLogcatViewer(activity)
                            }, 500)
                        } else {
                            android.util.Log.d("LogcatViewerLog", "权限仍未授予，继续等待")
                        }
                        return
                    }
                    
                    // 只在第一个 Activity resume 时启动一次
                    if (!hasLaunched) {
                        hasLaunched = true
                        android.util.Log.d("LogcatViewerLog", "检测到第一个 Activity resume: ${activity.javaClass.simpleName}")
                        // 延迟启动，避免全屏模式影响
                        activity.window.decorView.postDelayed({
                            android.util.Log.d("LogcatViewerLog", "开始从 ActivityLifecycleCallbacks 启动 LogcatViewer")
                            // 检查启动结果，如果是因为权限问题失败，标记为等待权限
                            val launched = INSTANCE?.launchLogcatViewerInternal(activity) ?: false
                            if (!launched) {
                                isWaitingForPermission = true
                                android.util.Log.d("LogcatViewerLog", "标记为等待权限授予状态")
                            }
                        }, 800)
                    }
                }
                
                override fun onActivityPaused(activity: android.app.Activity) {}
                override fun onActivityStarted(activity: android.app.Activity) {}
                override fun onActivityStopped(activity: android.app.Activity) {}
                override fun onActivityCreated(activity: android.app.Activity, savedInstanceState: android.os.Bundle?) {}
                override fun onActivitySaveInstanceState(activity: android.app.Activity, outState: android.os.Bundle) {}
                override fun onActivityDestroyed(activity: android.app.Activity) {}
            }
            
            lifecycleCallback?.let {
                application.registerActivityLifecycleCallbacks(it)
                android.util.Log.d("LogcatViewerLog", "已注册 ActivityLifecycleCallbacks，将在第一个 Activity resume 时自动启动 LogcatViewer")
            }
        }
    }
    
    override fun d(tag: String, message: String) {
        Log.d(tag, message)
    }
    
    override fun i(tag: String, message: String) {
        Log.i(tag, message)
    }
    
    override fun w(tag: String, message: String) {
        Log.w(tag, message)
    }
    
    override fun e(tag: String, message: String, throwable: Throwable?) {
        if (throwable != null) {
            Log.e(tag, message, throwable)
        } else {
            Log.e(tag, message)
        }
    }
    
    override fun log(level: LogLevel, tag: String, message: String, throwable: Throwable?) {
        when (level) {
            LogLevel.DEBUG -> d(tag, message)
            LogLevel.INFO -> i(tag, message)
            LogLevel.WARN -> w(tag, message)
            LogLevel.ERROR -> e(tag, message, throwable)
        }
    }
    
    override fun uploadLogs() {
        // LogcatViewer 默认不提供日志上传功能，可以在这里扩展
        // 或者由 app 模块提供自定义实现
    }
    
    override fun collectCrash(throwable: Throwable) {
        // 记录崩溃信息到 logcat，LogcatViewer 会自动捕获
        Log.e("Crash", "崩溃信息", throwable)
        // 注意：生产环境可能仍然需要收集崩溃信息，可以在这里扩展
        // 例如：上传到崩溃收集服务（Firebase Crashlytics、Bugly 等）
    }
    
    override fun launchLogcatViewer(context: Context) {
        launchLogcatViewerInternal(context)
    }
    
    /**
     * 内部方法：启动 LogcatViewer，返回是否成功启动（true=成功，false=需要权限）
     */
    private fun launchLogcatViewerInternal(context: Context): Boolean {
        try {
            // 检查 context 类型，必须是 Activity context
            if (context !is android.app.Activity) {
                Log.w("LogcatViewerLog", "launchLogcatViewer 需要 Activity context，当前是: ${context.javaClass.simpleName}，跳过启动")
                // 如果是 Application context，不执行启动，等待 Activity context
                return false
            }
            
            Log.d("LogcatViewerLog", "=== 开始启动 LogcatViewer ===")
            
            // 检查悬浮窗权限
            val hasOverlayPermission = if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
                android.provider.Settings.canDrawOverlays(context)
            } else {
                true
            }
            
            Log.d("LogcatViewerLog", "悬浮窗权限状态: $hasOverlayPermission, SDK版本: ${android.os.Build.VERSION.SDK_INT}")
            
            if (!hasOverlayPermission) {
                Log.w("LogcatViewerLog", "悬浮窗权限未授予，自动跳转到权限设置页面")
                // 自动跳转到权限设置页面（Application context 需要添加 FLAG_ACTIVITY_NEW_TASK）
                try {
                    val intent = android.content.Intent(
                        android.provider.Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
                        android.net.Uri.parse("package:${context.packageName}")
                    ).apply {
                        // 确保可以从 Application context 启动
                        addFlags(android.content.Intent.FLAG_ACTIVITY_NEW_TASK)
                    }
                    context.startActivity(intent)
                    Log.d("LogcatViewerLog", "已自动跳转到权限设置页面，请授予'在其他应用上层显示'权限")
                    
                    // 显示 Toast 提示用户（如果可能的话）
                    try {
                        android.widget.Toast.makeText(
                            context, 
                            "请在设置中开启'在其他应用上层显示'权限，然后返回应用", 
                            android.widget.Toast.LENGTH_LONG
                        ).show()
                    } catch (e: Exception) {
                        // Toast 可能失败，忽略
                    }
                } catch (e: Exception) {
                    Log.e("LogcatViewerLog", "跳转到权限设置失败", e)
                    e.printStackTrace()
                }
                return false // 返回 false 表示需要权限
            }
            
            // 有权限，显示悬浮按钮（点击按钮打开 LogcatViewer）
            Log.d("LogcatViewerLog", "开始显示悬浮日志按钮...")
            com.narutohuo.xindazhou.core.log.FloatingLogButton.show(context)
            Log.d("LogcatViewerLog", "悬浮日志按钮显示完成")
            
            return true // 返回 true 表示成功启动
            
        } catch (e: Exception) {
            Log.e("LogcatViewerLog", "启动 LogcatViewer 异常", e)
            Log.e("LogcatViewerLog", "异常类型: ${e.javaClass.name}")
            Log.e("LogcatViewerLog", "异常消息: ${e.message}")
            e.printStackTrace()
            return false
        }
    }
}

