package com.narutohuo.xindazhou.common.network.operator

import com.narutohuo.xindazhou.common.network.response.ApiResponse
import com.narutohuo.xindazhou.core.log.ILog
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

/**
 * 全局 API 响应处理器（参考 Sandwich Operator）
 * 
 * 统一处理所有 API 响应，例如：
 * - 全局错误处理（Toast 提示）
 * - 全局异常处理（日志记录）
 * - 统一日志记录
 * - 支持多个 Operator 链式调用
 * 
 * 注意：
 * - Token 刷新已在 TokenRefreshInterceptor 中统一处理，这里不再处理
 * - 这里主要用于 UI 提示、日志记录等全局统一的处理逻辑
 * 
 * 使用方式：
 * ```kotlin
 * // 方式1：使用简单的全局处理器（向后兼容）
 * GlobalApiOperator.globalErrorHandler = { error ->
 *     Toast.makeText(context, error.message, Toast.LENGTH_SHORT).show()
 * }
 * 
 * // 方式2：使用 Operator 接口（推荐，支持多个 Operator 链式调用）
 * GlobalApiOperator.addOperator(LogOperator())
 * GlobalApiOperator.addOperator(ToastOperator())
 * ```
 */
object GlobalApiOperator {
    
    private const val TAG = "GlobalApiOperator"
    
    // 多个 Operator 列表（支持链式调用）
    private val operators = mutableListOf<ApiResponseOperator<*>>()
    private val operatorsMutex = Mutex()
    
    /**
     * 全局错误处理器（向后兼容，保留）
     * 
     * 当响应为 Error（业务错误）时自动调用
     * 可以用于全局 Toast 提示、日志记录等
     * 
     * 示例：
     * ```kotlin
     * GlobalApiOperator.globalErrorHandler = { error ->
     *     Toast.makeText(context, error.message, Toast.LENGTH_SHORT).show()
     * }
     * ```
     */
    @Deprecated("建议使用 addOperator() 代替，支持多个 Operator 链式调用", ReplaceWith("addOperator(operator)"))
    var globalErrorHandler: ((ApiResponse.Error<*>) -> Unit)? = null
    
    /**
     * 全局异常处理器（向后兼容，保留）
     * 
     * 当响应为 Exception（网络异常）时自动调用
     * 可以用于全局错误提示、日志记录等
     * 
     * 示例：
     * ```kotlin
     * GlobalApiOperator.globalExceptionHandler = { exception ->
     *     ILog.e("Global", "API 异常: ${exception.exception.message}")
     * }
     * ```
     */
    @Deprecated("建议使用 addOperator() 代替，支持多个 Operator 链式调用", ReplaceWith("addOperator(operator)"))
    var globalExceptionHandler: ((ApiResponse.Exception<*>) -> Unit)? = null
    
    /**
     * 添加 Operator（支持多个 Operator 链式调用）
     * 
     * @param operator Operator 实例
     * 
     * 示例：
     * ```kotlin
     * GlobalApiOperator.addOperator(LogOperator())
     * GlobalApiOperator.addOperator(ToastOperator())
     * ```
     */
    suspend fun <T> addOperator(operator: ApiResponseOperator<T>) {
        operatorsMutex.withLock {
            @Suppress("UNCHECKED_CAST")
            operators.add(operator as ApiResponseOperator<*>)
        }
    }
    
    /**
     * 添加 Operator（同步版本）
     * 
     * @param operator Operator 实例
     */
    fun <T> addOperatorSync(operator: ApiResponseOperator<T>) {
        @Suppress("UNCHECKED_CAST")
        operators.add(operator as ApiResponseOperator<*>)
    }
    
    /**
     * 移除 Operator
     * 
     * @param operator Operator 实例
     */
    suspend fun <T> removeOperator(operator: ApiResponseOperator<T>) {
        operatorsMutex.withLock {
            operators.remove(operator)
        }
    }
    
    /**
     * 移除所有 Operator
     */
    suspend fun clearOperators() {
        operatorsMutex.withLock {
            operators.clear()
        }
    }
    
    /**
     * 应用全局处理器
     * 
     * 对响应应用全局处理逻辑（按顺序执行所有 Operator，然后执行向后兼容的处理器）
     * 
     * @param response API 响应
     * @return 处理后的响应（Operator 可以修改响应）
     * 
     * 注意：
     * - 先执行所有 Operator（支持链式调用）
     * - 然后执行向后兼容的全局处理器（只执行副作用）
     */
    suspend fun <T> apply(response: ApiResponse<T>): ApiResponse<T> {
        var result: ApiResponse<T> = response
        
        // 1. 按顺序执行所有 Operator（支持链式调用）
        val currentOperators = operatorsMutex.withLock {
            operators.toList() // 复制列表，避免在迭代时修改
        }
        
        for (operator in currentOperators) {
            try {
                @Suppress("UNCHECKED_CAST")
                val typedOperator = operator as? ApiResponseOperator<T>
                if (typedOperator != null) {
                    result = typedOperator.invoke(result)
                }
            } catch (e: Exception) {
                ILog.e(TAG, "Operator 执行失败: ${operator.javaClass.simpleName}, ${e.message}", e)
            }
        }
        
        // 2. 执行向后兼容的全局处理器（只执行副作用，不修改响应）
        when (result) {
            is ApiResponse.Success -> {
                // 成功响应，不处理
            }
            
            is ApiResponse.Error -> {
                try {
                    globalErrorHandler?.invoke(result)
                } catch (e: Exception) {
                    ILog.e(TAG, "全局错误处理器执行失败: ${e.message}", e)
                }
            }
            
            is ApiResponse.Exception -> {
                try {
                    globalExceptionHandler?.invoke(result)
                } catch (e: Exception) {
                    ILog.e(TAG, "全局异常处理器执行失败: ${e.message}", e)
                }
            }
        }
        
        return result
    }
    
    /**
     * 同步应用全局处理器（非 suspend 版本）
     * 
     * 适用于不需要 suspend 的场景
     * 
     * 注意：只执行向后兼容的全局处理器，不执行 Operator（因为 Operator 可能是 suspend 的）
     */
    fun <T> applySync(response: ApiResponse<T>): ApiResponse<T> {
        return when (response) {
            is ApiResponse.Success -> response
            
            is ApiResponse.Error -> {
                try {
                    globalErrorHandler?.invoke(response)
                } catch (e: Exception) {
                    ILog.e(TAG, "全局错误处理器执行失败: ${e.message}", e)
                }
                response
            }
            
            is ApiResponse.Exception -> {
                try {
                    globalExceptionHandler?.invoke(response)
                } catch (e: Exception) {
                    ILog.e(TAG, "全局异常处理器执行失败: ${e.message}", e)
                }
                response
            }
        }
    }
}
