package com.shukria.kiosklauncher.util
import android.util.Log
import org.java_websocket.client.WebSocketClient
import org.java_websocket.handshake.ServerHandshake
import java.net.URI
import javax.net.ssl.SSLContext
import javax.net.ssl.X509TrustManager

object WebSocketManager {

    var webSocketClient: WebSocketClient? = null
    private var eventListener: WebSocketEventListener? = null

    fun getInstance(): WebSocketManager = this

    fun initializeWebSocketConnection(serverUrl: String) {
        try {
            val uri = URI(serverUrl)

            // Initialize WebSocketClient
            webSocketClient = object : WebSocketClient(uri) {
                override fun onOpen(handshakedata: ServerHandshake?) {
                    Log.d("WebSocket", "Connection opened")
                    eventListener?.onWebSocketOpen()
                }

                override fun onMessage(message: String?) {
                    Log.d("WebSocket", "Message received: $message")
                    message?.let { eventListener?.onWebSocketMessage(it) }
                }

                override fun onClose(code: Int, reason: String?, remote: Boolean) {
                    Log.d("WebSocket", "Connection closed: Code=$code, Reason=$reason")
                    eventListener?.onWebSocketClose(code, reason ?: "")
                }

                override fun onError(ex: Exception?) {
                    Log.e("WebSocket", "Error occurred: ${ex?.message}")
                    ex?.let { eventListener?.onWebSocketError(it) }
                }
            }

            // SSL configuration for wss:// (if required)
            if (serverUrl.startsWith("wss://")) {
                val sslContext = SSLContext.getInstance("TLS")
                sslContext.init(null, arrayOf(TrustAllCerts()), java.security.SecureRandom())
                webSocketClient?.setSocket(sslContext.socketFactory.createSocket())
            }

            webSocketClient?.connect()
            Log.d("WebSocket", "Connecting to $serverUrl")

        } catch (e: Exception) {
            e.printStackTrace()
        }
    }

    fun setWebSocketEventListener(listener: WebSocketEventListener) {
        eventListener = listener
    }

    fun closeConnection() {
        webSocketClient?.close()
        webSocketClient = null
    }

    fun sendMessage(message: String) {
        if (webSocketClient != null && webSocketClient!!.isOpen) {
            webSocketClient!!.send(message)
        } else {
            Log.e("WebSocket", "WebSocket is not open")
        }
    }

    interface WebSocketEventListener {
        fun onWebSocketOpen()
        fun onWebSocketClose(code: Int, reason: String)
        fun onWebSocketError(ex: Exception)
        fun onWebSocketMessage(message: String)
    }

    // Trust Manager for SSL (bypass for self-signed certs)
    private class TrustAllCerts : X509TrustManager {
        override fun checkClientTrusted(chain: Array<out java.security.cert.X509Certificate>?, authType: String?) {}
        override fun checkServerTrusted(chain: Array<out java.security.cert.X509Certificate>?, authType: String?) {}
        override fun getAcceptedIssuers(): Array<java.security.cert.X509Certificate>? = null
    }
}