package com.xw.yunwei.websocket

import android.content.Context
import android.net.ConnectivityManager
import android.net.Network
import android.net.NetworkCapabilities
import android.net.NetworkRequest
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import com.xw.common.utils.LogUtils
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.MutableSharedFlow
import kotlinx.coroutines.flow.SharedFlow
import kotlinx.coroutines.flow.asSharedFlow
import kotlinx.coroutines.launch
import okio.ByteString

// WebSocket管理器（单例）
object WebSocketManager : IWebSocketListener {
    private const val TAG = "WebSocketManager"
    private lateinit var webSocketClient: WebSocketClient
    private var isInitialized = false
    private var enableConnect = false

    private val mainCoroutineScope: CoroutineScope = CoroutineScope(Dispatchers.Main)

    // 连接状态LiveData
    private val _connectionState = MutableLiveData<WebSocketClient.ConnectionState>()
    val connectionState: LiveData<WebSocketClient.ConnectionState> = _connectionState

    // 消息LiveData
    private val _messageEvent = MutableLiveData<Event<String>>()
    val messageEvent: LiveData<Event<String>> = _messageEvent

    // 事件Flow
    private val _eventFlow = MutableSharedFlow<WebSocketEvent>()
    val eventFlow: SharedFlow<WebSocketEvent> = _eventFlow.asSharedFlow()

    /**
     * 初始化
     */
    fun initialize(context: Context) {
        if (isInitialized) return

        webSocketClient = WebSocketClient()
        webSocketClient.addListener(this)

        // 监听网络状态
        observeNetworkState(context)

        isInitialized = true
        LogUtils.i(TAG, "WebSocket管理器初始化完成")
    }

    /**
     * 连接WebSocket
     */
    fun connect() {
        if (!isInitialized) {
            LogUtils.e(TAG, "请先调用initialize()初始化")
            return
        }
        enableConnect = true
        webSocketClient.connect(true)
    }

    /**
     * 断开连接
     */
    fun disconnect() {
        if (isInitialized) {
            enableConnect = false
            webSocketClient.disconnect()
        }
    }

    /**
     * 发送消息
     */
    fun sendMessage(message: String): Boolean {
        return if (isInitialized) {
            webSocketClient.sendMessage(message)
        } else {
            false
        }
    }

    /**
     * 发送JSON消息
     */
    fun sendJson(type: String, data: Map<String, Any> = emptyMap()): Boolean {
        return if (isInitialized) {
            webSocketClient.sendJsonMessage(type, data)
        } else {
            false
        }
    }

    /**
     * 重新连接
     */
    fun reconnect() {
        if (isInitialized && enableConnect) {
            webSocketClient.reconnect()
        }
    }

    /**
     * 获取连接状态
     */
    fun getConnectionState(): WebSocketClient.ConnectionState {
        return if (isInitialized) {
            webSocketClient.getConnectionState()
        } else {
            WebSocketClient.ConnectionState.DISCONNECTED
        }
    }

    /**
     * 清理资源
     */
    fun release() {
        if (isInitialized) {
            webSocketClient.disconnect()
            webSocketClient.clearListeners()
            isInitialized = false
        }
    }

    // 实现IWebSocketListener接口
    override fun onConnected() {
        LogUtils.i(TAG, "WebSocket已连接")
        _connectionState.postValue(WebSocketClient.ConnectionState.CONNECTED)

        mainCoroutineScope.launch {
            _eventFlow.emit(WebSocketEvent.Connected)
        }
    }

    override fun onConnectFailed(t: Throwable) {
        LogUtils.e(TAG, "连接失败: ${t.message}")
        _connectionState.postValue(WebSocketClient.ConnectionState.DISCONNECTED)

        mainCoroutineScope.launch {
            _eventFlow.emit(WebSocketEvent.ConnectFailed(t))
        }
    }

    override fun onMessage(text: String) {
        LogUtils.d(TAG, "收到消息: $text")
        _messageEvent.postValue(Event(text))

        mainCoroutineScope.launch {
            _eventFlow.emit(WebSocketEvent.Message(text))
        }
    }

    override fun onMessage(bytes: ByteString) {
        LogUtils.d(TAG, "收到二进制消息, 长度: ${bytes.size}")

        mainCoroutineScope.launch {
            _eventFlow.emit(WebSocketEvent.BinaryMessage(bytes))
        }
    }

    override fun onDisconnected(code: Int, reason: String) {
        LogUtils.w(TAG, "连接断开: code=$code, reason=$reason")
        _connectionState.postValue(WebSocketClient.ConnectionState.DISCONNECTED)

        mainCoroutineScope.launch {
            _eventFlow.emit(WebSocketEvent.Disconnected(code, reason))
        }
    }

    override fun onNetworkStateChanged(isAvailable: Boolean) {
        if (isAvailable && getConnectionState() == WebSocketClient.ConnectionState.DISCONNECTED) {
            // 网络恢复时重连
            reconnect()
        }
    }

    override fun onSendMessageSuccess(message: String) {
        LogUtils.d(TAG, "发送消息成功: $message")
    }

    override fun onSendMessageFailed(message: String, t: Throwable) {
        LogUtils.e(TAG, "发送消息失败: ${t.message}")
    }

    // 网络状态监听
    private fun observeNetworkState(context: Context) {
        val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE)
                as ConnectivityManager

        val networkCallback = object : ConnectivityManager.NetworkCallback() {
            override fun onAvailable(network: Network) {
                LogUtils.i(TAG, "网络已连接")
                onNetworkStateChanged(true)
            }

            override fun onLost(network: Network) {
                LogUtils.w(TAG, "网络已断开")
                onNetworkStateChanged(false)
            }
        }

        val request = NetworkRequest.Builder()
            .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
            .build()

        connectivityManager.registerNetworkCallback(request, networkCallback)
    }

    // Event包装类（避免LiveData重复触发）
    class Event<T>(private val content: T) {
        private var hasBeenHandled = false

        fun getContentIfNotHandled(): T? {
            return if (hasBeenHandled) {
                null
            } else {
                hasBeenHandled = true
                content
            }
        }
    }

    // WebSocket事件密封类
    sealed class WebSocketEvent {
        object Connected : WebSocketEvent()
        data class ConnectFailed(val throwable: Throwable) : WebSocketEvent()
        data class Message(val text: String) : WebSocketEvent()
        data class BinaryMessage(val bytes: ByteString) : WebSocketEvent()
        data class Disconnected(val code: Int, val reason: String) : WebSocketEvent()
    }
}