package com.narutohuo.xindazhou.common.permission

import android.app.Activity
import android.content.Context
import android.content.pm.PackageManager
import androidx.activity.ComponentActivity
import androidx.activity.result.ActivityResultLauncher
import androidx.activity.result.contract.ActivityResultContracts
import androidx.core.content.ContextCompat
import androidx.fragment.app.Fragment
import com.narutohuo.xindazhou.common.dialog.DialogHelper

/**
 * 权限管理封装
 * 
 * 统一封装 Android 权限请求功能，提供便捷的权限管理方式
 * 
 * 使用方式：
 * ```kotlin
 * // 在 Activity 中注册权限请求
 * private val requestPermissionLauncher = PermissionHelper.registerRequestPermission(this) { permissions ->
 *     // 处理权限请求结果
 *     permissions.forEach { (permission, granted) ->
 *         if (granted) {
 *             // 权限已授予
 *         } else {
 *             // 权限被拒绝
 *         }
 *     }
 * }
 * 
 * // 请求单个权限
 * PermissionHelper.requestPermission(activity, Manifest.permission.CAMERA) { granted ->
 *     if (granted) {
 *         // 权限已授予
 *     }
 * }
 * 
 * // 请求多个权限
 * PermissionHelper.requestPermissions(activity, arrayOf(
 *     Manifest.permission.CAMERA,
 *     Manifest.permission.READ_EXTERNAL_STORAGE
 * )) { permissions ->
 *     // 处理权限结果
 * }
 * ```
 */
object PermissionHelper {
    
    /**
     * 注册权限请求器（Activity）
     * 
     * @param activity ComponentActivity 实例
     * @param onResult 权限请求结果回调（Map<权限名, 是否授予>）
     * @return ActivityResultLauncher，调用 launch() 启动权限请求
     */
    fun registerRequestPermission(
        activity: ComponentActivity,
        onResult: (Map<String, Boolean>) -> Unit
    ): ActivityResultLauncher<Array<String>> {
        return activity.registerForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { permissions ->
            onResult(permissions)
        }
    }
    
    /**
     * 注册权限请求器（Fragment）
     * 
     * @param fragment Fragment 实例
     * @param onResult 权限请求结果回调
     * @return ActivityResultLauncher
     */
    fun registerRequestPermission(
        fragment: Fragment,
        onResult: (Map<String, Boolean>) -> Unit
    ): ActivityResultLauncher<Array<String>> {
        return fragment.registerForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { permissions ->
            onResult(permissions)
        }
    }
    
    /**
     * 注册单个权限请求器（Activity）
     * 
     * @param activity ComponentActivity 实例
     * @param onResult 权限请求结果回调（是否授予）
     * @return ActivityResultLauncher，调用 launch() 启动权限请求
     */
    fun registerRequestSinglePermission(
        activity: ComponentActivity,
        onResult: (Boolean) -> Unit
    ): ActivityResultLauncher<String> {
        return activity.registerForActivityResult(ActivityResultContracts.RequestPermission()) { granted ->
            onResult(granted)
        }
    }
    
    /**
     * 注册单个权限请求器（Fragment）
     * 
     * @param fragment Fragment 实例
     * @param onResult 权限请求结果回调
     * @return ActivityResultLauncher
     */
    fun registerRequestSinglePermission(
        fragment: Fragment,
        onResult: (Boolean) -> Unit
    ): ActivityResultLauncher<String> {
        return fragment.registerForActivityResult(ActivityResultContracts.RequestPermission()) { granted ->
            onResult(granted)
        }
    }
    
    /**
     * 检查权限是否已授予
     * 
     * @param context 上下文
     * @param permission 权限名称
     * @return true 表示已授予，false 表示未授予
     */
    fun checkPermission(context: Context, permission: String): Boolean {
        return ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED
    }
    
    /**
     * 检查多个权限是否已授予
     * 
     * @param context 上下文
     * @param permissions 权限名称数组
     * @return Map<权限名, 是否授予>
     */
    fun checkPermissions(context: Context, permissions: Array<String>): Map<String, Boolean> {
        return permissions.associateWith { permission ->
            checkPermission(context, permission)
        }
    }
    
    /**
     * 检查所有权限是否都已授予
     * 
     * @param context 上下文
     * @param permissions 权限名称数组
     * @return true 表示所有权限都已授予
     */
    fun checkAllPermissionsGranted(context: Context, permissions: Array<String>): Boolean {
        return permissions.all { checkPermission(context, it) }
    }
    
    /**
     * 请求单个权限（简化版，需要先注册）
     * 
     * @param launcher ActivityResultLauncher（通过 registerRequestSinglePermission 获取）
     * @param permission 权限名称
     */
    fun requestPermission(launcher: ActivityResultLauncher<String>, permission: String) {
        launcher.launch(permission)
    }
    
    /**
     * 请求多个权限（简化版，需要先注册）
     * 
     * @param launcher ActivityResultLauncher（通过 registerRequestPermission 获取）
     * @param permissions 权限名称数组
     */
    fun requestPermissions(launcher: ActivityResultLauncher<Array<String>>, permissions: Array<String>) {
        launcher.launch(permissions)
    }
    
    /**
     * 检查权限是否应该显示说明（用户之前拒绝过）
     * 
     * @param activity Activity 实例
     * @param permission 权限名称
     * @return true 表示应该显示说明
     */
    fun shouldShowRequestPermissionRationale(activity: Activity, permission: String): Boolean {
        return activity.shouldShowRequestPermissionRationale(permission)
    }
    
    /**
     * 检查权限是否应该显示说明（Fragment）
     * 
     * @param fragment Fragment 实例
     * @param permission 权限名称
     * @return true 表示应该显示说明
     */
    fun shouldShowRequestPermissionRationale(fragment: Fragment, permission: String): Boolean {
        return fragment.shouldShowRequestPermissionRationale(permission)
    }
    
    /**
     * 请求权限（带说明对话框，如果用户之前拒绝过）
     * 
     * @param activity ComponentActivity 实例
     * @param permission 权限名称
     * @param rationale 权限说明文本
     * @param onRationaleConfirmed 用户确认说明后的回调（在这里执行实际权限请求）
     * @param onResult 权限请求结果回调
     */
    fun requestPermissionWithRationale(
        activity: ComponentActivity,
        permission: String,
        rationale: String,
        onRationaleConfirmed: () -> Unit,
        onResult: (Boolean) -> Unit
    ) {
        if (checkPermission(activity, permission)) {
            // 权限已授予
            onResult(true)
            return
        }
        
        if (shouldShowRequestPermissionRationale(activity, permission)) {
            // 用户之前拒绝过，显示说明对话框
            com.narutohuo.xindazhou.common.dialog.DialogHelper.showConfirm(
                activity,
                "权限说明",
                rationale,
                confirmText = "确定",
                cancelText = "取消",
                onConfirm = {
                    onRationaleConfirmed()
                },
                onCancel = {
                    onResult(false)
                }
            )
        } else {
            // 直接请求权限
            onRationaleConfirmed()
        }
    }
    
    /**
     * 请求权限（带说明对话框，Fragment 版本）
     * 
     * @param fragment Fragment 实例
     * @param permission 权限名称
     * @param rationale 权限说明文本
     * @param onRationaleConfirmed 用户确认说明后的回调
     * @param onResult 权限请求结果回调
     */
    fun requestPermissionWithRationale(
        fragment: Fragment,
        permission: String,
        rationale: String,
        onRationaleConfirmed: () -> Unit,
        onResult: (Boolean) -> Unit
    ) {
        if (checkPermission(fragment.requireContext(), permission)) {
            // 权限已授予
            onResult(true)
            return
        }
        
        if (shouldShowRequestPermissionRationale(fragment, permission)) {
            // 用户之前拒绝过，显示说明对话框
            DialogHelper.showConfirm(
                fragment.requireContext(),
                "权限说明",
                rationale,
                confirmText = "确定",
                cancelText = "取消",
                onConfirm = {
                    onRationaleConfirmed()
                },
                onCancel = {
                    onResult(false)
                }
            )
        } else {
            // 直接请求权限
            onRationaleConfirmed()
        }
    }
}

