package relax.offline.music

import android.app.Application
import android.content.Context
import androidx.annotation.OptIn
import androidx.media3.common.util.UnstableApi
import relax.offline.music.bean.Audio
import relax.offline.music.bean.CurrentPlayingAudio
import relax.offline.music.bean.ResourcesList
import relax.offline.music.database.AppOfflineDBManager
import relax.offline.music.database.CurrentAudioManager
import relax.offline.music.database.DatabaseManager
import relax.offline.music.media.LocalMediaControllerManager
import relax.offline.music.media.MediaControllerManager
import relax.offline.music.util.CacheManager
import relax.offline.music.util.DownloadUtil
import relax.offline.music.util.parseResources
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import relax.offline.music.database.AppFavoriteDBManager
import relax.offline.music.firebase.RemoteConfig
import relax.offline.music.http.CommonIpInfoUtil
import relax.offline.music.http.UploadEventName
import relax.offline.music.util.AnalysisUtil
import relax.offline.music.util.AppLifecycleHandler
import java.io.BufferedReader
import java.io.InputStreamReader
import java.util.concurrent.atomic.AtomicBoolean

@OptIn(UnstableApi::class)
class App : Application() {
    companion object {
        lateinit var app: App
            private set
        lateinit var appFavoriteDBManager: AppFavoriteDBManager
            private set
        lateinit var appOfflineDBManager: AppOfflineDBManager
            private set
        lateinit var currentAudioManager: CurrentAudioManager
            private set
        lateinit var databaseManager: DatabaseManager
            private set
        var currentPlayingAudio: CurrentPlayingAudio? = null
            private set
        lateinit var importList: List<Audio>
            private set
        lateinit var resourcesList: ResourcesList
            private set

        lateinit var realHumanVoiceList: List<Audio>
            private set

        lateinit var soundsOfAppliancesList: List<Audio>
            private set

        lateinit var soundsOfNatureList: List<Audio>
            private set

        private var isInitialized = false

        fun initialize(context: Context) {
            if (!isInitialized) {
                val jsonString = readAssetsFile(context)
                resourcesList = parseResources(context, jsonString)
                splitResourcesList()
                isInitialized = true
            }
        }

        fun initCurrentPlayingAudio() {
            CoroutineScope(Dispatchers.IO).launch {
                currentPlayingAudio = currentAudioManager.getCurrentPlayingAudio()
            }
        }

        fun initImportAudio(callback: (List<Audio>) -> Unit = {}) {
            CoroutineScope(Dispatchers.IO).launch {
                importList = databaseManager.getAllAudioFiles()
                withContext(Dispatchers.Main) {
                    callback(importList)
                }
            }
        }

        private fun readAssetsFile(context: Context): String {
            val assetManager = context.assets
            val inputStream = assetManager.open("resources.json")
            val bufferedReader = BufferedReader(InputStreamReader(inputStream))
            val stringBuilder = StringBuilder()
            var line: String?
            while (bufferedReader.readLine().also { line = it } != null) {
                stringBuilder.append(line)
            }
            return stringBuilder.toString()
        }

        private fun splitResourcesList() {
            realHumanVoiceList = mutableListOf()
            soundsOfAppliancesList = mutableListOf()
            soundsOfNatureList = mutableListOf()

            for (category in resourcesList.categories) {
                when (category.name) {
                    "Sound of instrument" -> realHumanVoiceList = category.audios
                    "White noise" -> soundsOfAppliancesList = category.audios
                    "Voice of Nature" -> soundsOfNatureList = category.audios
                }
            }
        }
    }

    var isAdShowing: AtomicBoolean = AtomicBoolean(false)//是否正在广告界面

    override fun onCreate() {
        super.onCreate()
        AnalysisUtil.logEvent(AnalysisUtil.USER_LAUNCH)
        app = this
        AppLifecycleHandler(this)
        CommonIpInfoUtil.shared.initIPInfo()
        UploadEventName.shared.init(this)
        RemoteConfig.instance.init(this)
        initialize(this)
        MediaControllerManager.init(this)
        LocalMediaControllerManager.init(this)
        appOfflineDBManager = AppOfflineDBManager.getInstance(this)
        appFavoriteDBManager = AppFavoriteDBManager.getInstance(this)
        currentAudioManager = CurrentAudioManager.getInstance(this)
        databaseManager = DatabaseManager.getInstance(this)
        initCurrentPlayingAudio()
        initImportAudio()
        CacheManager.initializeCaches(this)
        DownloadUtil.getDownloadManager(this)
    }
}