/**
 * Web socket session with receive type [I]. Open automatically with subscribe on [incoming]
 */
interface WSSession<T> {
    /**
     * Incoming messages flow
     */
    val incoming: Flow<Result<T>>

    /**
     * Flush and close WS
     */
    suspend fun close()

    /**
     * WS network connect state. Empty before first connect
     */
    val connectState: Flow<ConnectState>

    /**
     * return true while not called [close] after return false.
     *
     * while socket closing also return false
     *
     * while socket not open first time also return true
     */
    val isOpen: Boolean
}


enum class ConnectState {
    Connected,
    Disconnected
}

inline fun <reified T> HttpClient.wsSession(
    url: String,
    connectivityProvider: ConnectivityProvider,
): WSSession<T> = object : WSSession<T> {
    private var isClosed = false
    private var innerWSSession: WebSocketSession? = null

    override val connectState = MutableSharedFlow<ConnectState>(1)
    override val isOpen: Boolean
        get() = !isClosed

    override val incoming: Flow<Result<T>> = flow<Result<T>> {
        if (isClosed) return@flow
        val ws = webSocketSession(urlString = url)
        innerWSSession = ws
        if (isClosed) {
            ws.close()
            emit(Result.failure(NoData))
            return@flow
        }
        connectState.emit(ConnectState.Connected)
        emitAll(ws.incoming.receiveAsFlow().map { frame -> requestWrapperWs(frame) })
    }.retry { cause: Throwable ->
        if (cause is IOException || cause is HttpRequestTimeoutException) {
            connectState.emit(ConnectState.Disconnected)
            connectivityProvider.waitConnect()
        }
        true
    }.filter { isOpen }

    override suspend fun close() {
        isClosed = true
        innerWSSession?.close()
    }

}


suspend inline fun <reified T> requestWrapperWs(
    frame: Frame,
): Result<T> = requestWrapperWs(frame) {
    when (this) {
        is Frame.Close -> throw CancellationException(this.data.decodeToString())
        is Frame.Ping -> throw NoData
        is Frame.Pong -> throw NoData
        is Frame.Text -> commonJsonConfig.decodeFromString(this.readText())
        is Frame.Binary -> commonJsonConfig.decodeFromString(this.data.decodeToString())
        else -> throw NoData
    }
}

suspend inline fun <reified T> requestWrapperWs(
    frame: Frame,
    modifier: Frame.() -> T,
): Result<T> = catching { frame.modifier() }

val commonJsonConfig = Json {
    ignoreUnknownKeys = true
    allowSpecialFloatingPointValues = true
}

/**
 * no data - Anywhere. When data not set
 */
object NoData : Throwable()

var lastOpenSession: WSSession<*>? = null
_url.onEach { url ->
    lastOpenSession?.close()
    val session = httpClient.wsSession(
        url = url,
        connectivityProvider = connectivityProvider,
    )
    lastOpenSession = session
    session.incoming.onSuccess {
        //your code
    }.launchIn(CoroutineScope(Dispatchers.Default))
    session.connectState.onEach { state ->
        _hasProgress.value = state == ConnectState.Disconnected
    }.launchIn(this)
}.launchIn(storeScope).invokeOnCompletion {
    CoroutineScope(Dispatchers.Default).launch { lastOpenSession?.close() }
}