cpaas-compose/cpaas-lite/src/main/java/io/nexilis/service/Api.kt

package io.nexilis.service

import android.app.Activity
import android.content.Context
import android.content.Intent
import android.os.Build
import android.util.Base64
import android.util.Log
import android.widget.Toast
import com.google.firebase.Firebase
import com.google.firebase.FirebaseApp
import com.google.firebase.FirebaseOptions
import com.google.firebase.app
import com.google.firebase.initialize
import io.newuniverse.SDK.nuSDKService
import io.nexilis.service.core.Data
import io.nexilis.service.core.Network
import io.nexilis.service.core.api
import io.nexilis.service.core.decrypt
import io.nexilis.service.core.domain
import io.nexilis.service.core.isLogin
import io.nexilis.service.core.pref
import io.nexilis.service.core.pin
import io.nexilis.service.core.session
import kotlinx.coroutines.launch
import org.json.JSONObject
import java.security.SecureRandom
import java.util.Locale
import java.util.concurrent.TimeUnit
import java.util.concurrent.locks.Condition
import java.util.concurrent.locks.ReentrantLock
import kotlin.concurrent.withLock

class Api {

    companion object {
        internal val lock = ReentrantLock()

        internal var condition: Condition? = null

        fun connect(account: String, activity: Activity) {
            Log.d(tag, "connect:$account")
            activity.startService(Intent(activity, nuSDKService::class.java))
            Thread {
                try {
                    val urlData = Network().getSync("https://nexilis.io/dipp/NuN1v3rs3/Qm3r4i0/get_ip_domain?account=$account") ?: return@Thread
                    Log.d(tag, "urlData:${urlData}")
                    val decode = Base64.decode(urlData, Base64.DEFAULT).toString(Charsets.UTF_8)
                    val json = JSONObject(decode.decrypt())
                    val arrayAddress = json.getJSONArray("address")
                    val domain = json.getString("domain")
                    val address = arrayAddress.getJSONObject(0)
                    val ip = address.getString("ip")
                    val port = address.getString("portA").toInt()
                    activity.pref().domain = domain
                    Log.d(tag, "domain:${activity.pref().domain}")
                    val options = FirebaseOptions.Builder()
                        .setProjectId("push-kit-de2e3")
                        .setApplicationId("1:36827599888:android:29e65c0ec8a560c5916695")
                        .setApiKey("AIzaSyCLMlbL2GSDy7RVpw0dS55efV2uljB3R2U")
                        .build()
                    try {
                        Firebase.app(FirebaseApp.DEFAULT_APP_NAME)
                        Firebase.initialize(activity.applicationContext, options, "nexilis")
                    } catch (e: Exception) {
                        Firebase.initialize(activity.applicationContext, options, FirebaseApp.DEFAULT_APP_NAME)
                    }
                    while (!nuSDKService.bServiceStarted()) {
                        Thread.sleep(100)
                    }
                    val preferences = activity.pref()
                    preferences.api = account
                    val random =
                        String.format(Locale.getDefault(), "%010d", SecureRandom().nextInt(Int.MAX_VALUE))
                    val session = preferences.session.ifEmpty { random }
                    Log.d(tag, "initConnection:$pass,$account,$activity,$session")
                    nuSDKService.getInstance(pass).initConnection(
                        pass,
                        account,
                        activity,
                        SdkCallback::class.java,
                        SdkCallback(),
                        ip,
                        port,
                        session,
                        "09:00",
                        false,
                        "$ip:$port"
                    )
                    val signature: String = nuSDKService.getInstance(pass).sGetSignature()
                    if ("1,1,1,1,1,1,1,1,1,1,1,1" != signature) nuSDKService.getInstance(pass)
                        .UpdateSignature()
                    if (preferences.pin.isEmpty()) {
                        condition = lock.newCondition()
                        lock.withLock {
                            Log.d(tag, "wait:connection")
                            condition?.let {
                                val await = it.await(15, TimeUnit.SECONDS)
                                Log.d(tag, "wait:result:$await")
                                if (!await) {
                                    activity.runOnUiThread {
                                        Toast.makeText(activity, "Please check your internet connection", Toast.LENGTH_LONG).show()
                                    }
                                    return@Thread
                                }
                                Log.d(tag, "signup:start")
                                preferences.session = session
                                val response = Service.sendSync(
                                    Data(
                                        code = "SUA01",
                                        status = System.nanoTime().toString(),
                                        bodies = mutableMapOf("Api" to account)
                                    )
                                )
                                Log.d(tag, "signup:response:$response")
                                response?.let { r ->
                                    Log.d(tag, "signup:isOk:${r.isOk()}")
                                    if (r.isOk()) {
                                        val p = r.bodies["A00"] ?: ""
                                        Log.d(tag, "signup:put:pin:$p")
                                        preferences.pin = p
                                        Log.d(tag, "signup:retrieve")
                                        Service.sendAsync(
                                            Data(
                                                code = "A050",
                                                status = System.nanoTime().toString(),
                                            )
                                        )
                                    }
                                }
                            }
                        }
                    }
                    Log.d(tag, "user pin: ${preferences.pin}")
                } catch (e: Exception) {
                    Log.e(tag, e.message, e)
                }
            }.start()
        }

        internal fun sendToken(context: Context, token: String) {
            val pin = context.pref().pin
            if (context.pref().isLogin && pin.isNotEmpty()) {
                apiScope.launch {
                    Service.sendAsync(
                        Data(
                            code = "ATO",
                            status = System.nanoTime().toString(),
                            f_pin = pin,
                            bodies = mutableMapOf(
                                "TKN" to token, "Bo" to Build.BRAND
                            )
                        )
                    )
                }
            }
        }

        fun version(): String? {
            return nuSDKService.getInstance(pass)?.sGetVersion()
        }

        fun isConnected(): Boolean {
            return nuSDKService.getInstance(pass)?.nGetCLXConnState() == 1.toByte()
        }
    }
}