SmartPlateCabinet/app/src/main/java/com/sw/platecabinet/utils/PermissionHelper.kt

package com.sw.platecabinet.utils

import android.app.Activity
import android.content.Context
import android.content.Intent
import android.content.pm.PackageManager
import android.net.Uri
import android.provider.Settings
import androidx.appcompat.app.AlertDialog
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat

class PermissionHelper private constructor(
    private val context: Context,
    private val permissions: Array<String>,
    private val requestCode: Int,
    private val rationale: String? = null
) {
    private var onGranted: (() -> Unit)? = null

    companion object {
        /**
         * 创建权限请求构建器
         * @param context 上下文（Activity或Fragment）
         * @param permissions 需要请求的权限数组
         * @param requestCode 请求码
         */
        fun with(context: Context, permissions: Array<String>, requestCode: Int): Builder {
            return Builder(context, permissions, requestCode)
        }

        /**
         * 检查是否已授予所有权限
         */
        fun areAllPermissionsGranted(context: Context, permissions: Array<String>): Boolean {
            return permissions.all { permission ->
                ContextCompat.checkSelfPermission(
                    context,
                    permission
                ) == PackageManager.PERMISSION_GRANTED
            }
        }

        /**
         * 处理权限请求结果（供BaseActivity/BaseFragment调用）
         */
        fun handlePermissionResult(
            context: Context,
            requestCode: Int,
            permissions: Array<out String>,
            grantResults: IntArray,
            onPermissionPermanentlyDenied: (List<String>) -> Unit
        ): Boolean {
            if (grantResults.all { it == PackageManager.PERMISSION_GRANTED }) {
                return true
            }

            val permanentlyDeniedPermissions = mutableListOf<String>()
            permissions.forEachIndexed { index, permission ->
                if (grantResults[index] != PackageManager.PERMISSION_GRANTED) {
                    if (!ActivityCompat.shouldShowRequestPermissionRationale(
                            context as Activity,
                            permission
                        )
                    ) {
                        permanentlyDeniedPermissions.add(permission)
                    }
                }
            }

            if (permanentlyDeniedPermissions.isNotEmpty()) {
                onPermissionPermanentlyDenied(permanentlyDeniedPermissions)
            }
            return false
        }

        /**
         * 跳转到应用设置页面
         */
        fun openAppSettings(context: Context) {
            val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
                data = Uri.fromParts("package", context.packageName, null)
            }
            if (context is Activity) {
                context.startActivity(intent)
            }
        }
    }

    class Builder(
        private val context: Context,
        private val permissions: Array<String>,
        private val requestCode: Int
    ) {
        private var rationale: String? = null

        /**
         * 设置权限说明（当需要向用户解释权限用途时显示）
         */
        fun setRationale(rationale: String): Builder {
            this.rationale = rationale
            return this
        }

        /**
         * 设置权限授予回调
         */
        fun onGranted(callback: () -> Unit): PermissionHelper {
            val helper = PermissionHelper(context, permissions, requestCode, rationale)
            helper.onGranted = callback
            return helper
        }
    }

    /**
     * 检查并请求权限
     */
    fun checkAndRequest() {
        if (areAllPermissionsGranted(context, permissions)) {
            onGranted?.invoke()
        } else {
            requestPermissions()
        }
    }

    private fun requestPermissions() {
        val activity = context as? Activity ?: return

        // 检查是否需要显示权限说明
        val shouldShowRationale = permissions.any { permission ->
            ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)
        }

        if (shouldShowRationale && rationale != null) {
            // 显示解释对话框
            AlertDialog.Builder(activity)
                .setTitle("权限说明")
                .setMessage(rationale)
                .setPositiveButton("确定") { _, _ ->
                    doRequestPermissions(activity)
                }
                .setNegativeButton("取消", null)
                .show()
        } else {
            // 直接请求权限
            doRequestPermissions(activity)
        }
    }

    private fun doRequestPermissions(activity: Activity) {
        ActivityCompat.requestPermissions(activity, permissions, requestCode)
    }
}