package com.example.modifier.repo

import android.content.Context
import android.os.Handler
import android.os.Looper
import android.util.Log
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.Observer
import com.example.modifier.enums.RcsConfigureState
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.isActive
import kotlinx.coroutines.suspendCancellableCoroutine
import kotlinx.coroutines.withContext
import kotlinx.coroutines.withTimeoutOrNull
import org.apache.commons.collections4.queue.CircularFifoQueue
import kotlin.coroutines.resume
import kotlin.time.Duration

class GoogleMessageStateRepository(context: Context) {
    private val handler = Handler(Looper.getMainLooper())
    val logs = MutableLiveData<String>()
    val rcsConfigureState = MutableLiveData(RcsConfigureState.CONFIGURED)

    suspend fun startLogging() {
        try {
            val logsCache = CircularFifoQueue<String>(128)
            val p = Runtime.getRuntime().exec("su")
            p.outputStream.bufferedWriter().use { writer ->
                writer.write("logcat -c")
                writer.newLine()
                writer.flush()
                writer.write("logcat BugleRcsEngine:D *:S -v time")
                writer.newLine()
                writer.flush()
            }
            p.inputStream
                .bufferedReader()
                .useLines { lines ->
                    lines.forEach { line ->
                        if (line.contains("destState=CheckPreconditionsState")) {
                            rcsConfigureState.postValue(RcsConfigureState.NOT_CONFIGURED)
                        } else if (line.contains("destState=ReadyState")) {
                            rcsConfigureState.postValue(RcsConfigureState.READY)
                        } else if (line.contains("destState=WaitingForOtpState")) {
                            rcsConfigureState.postValue(RcsConfigureState.WAITING_FOR_OTP)
                        } else if (line.contains("destState=VerifyOtpState")) {
                            rcsConfigureState.postValue(RcsConfigureState.VERIFYING_OTP)
                        } else if (line.contains("destState=ConfiguredState")) {
                            rcsConfigureState.postValue(RcsConfigureState.CONFIGURED)
                        } else if (line.contains("destState=WaitingForRcsDefaultOnState")) {
                            rcsConfigureState.postValue(RcsConfigureState.WAITING_FOR_DEFAULT_ON)
                        } else if (line.contains("destState=WaitingForGoogleTosState")) {
                            rcsConfigureState.postValue(RcsConfigureState.WAITING_FOR_TOS)
                        } else if (line.contains("destState=RetryState")) {
                            rcsConfigureState.postValue(RcsConfigureState.RETRY)
                        } else if (line.contains("destState=ReplayRequestState")) {
                            rcsConfigureState.postValue(RcsConfigureState.REPLAY_REQUEST)
                        }
                        Regex("(?<time>\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2}.\\d{3}) I/BugleRcsEngine\\(\\W*\\d+\\): (?<log>.*)")
                            .matchEntire(line)
                            ?.apply {
                                val time = groups["time"]?.value?.dropLast(4)
                                val log = groups["log"]?.value
                                    ?.replace(Regex("\\[\\w+-\\w+-\\w+-\\w+-\\w+]"), "")
                                    ?.replace(Regex("\\[CONTEXT.*]"), "")
                                    ?.trim()

                                if (time != null && log != null) {
                                    if (log.contains("destState=")) {
                                        logsCache.add("$time: $log")
                                        logs.postValue(logsCache.joinToString("\n"))
                                        delay(100)
                                        logs.postValue(logsCache.joinToString("\n"))
                                    }
                                }
                            }
                    }
                }
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }

    suspend fun waitForRcsState(
        states: Array<RcsConfigureState>,
        timeout: Duration
    ): RcsConfigureState? {
        var state: RcsConfigureState? = null
        withTimeoutOrNull(timeout) {
            withContext(Dispatchers.Main) {
                suspendCancellableCoroutine { continuation ->
                    val observer = Observer<RcsConfigureState> { value ->
                        if (states.contains(value)) {
                            state = value
                            if (isActive)
                                continuation.resume(Unit)
                        }
                    }

                    rcsConfigureState.observeForever(observer)

                    continuation.invokeOnCancellation {
                        handler.post {
                            Log.i(com.example.modifier.TAG, "removeObserver")
                            rcsConfigureState.removeObserver(observer)
                        }
                    }
                }
            }
            false
        }
        return state
    }

    fun updateRcsState(state: RcsConfigureState) {
        rcsConfigureState.postValue(state)
    }
}