package com.fireworksdk.bridge.reactnative

import android.app.Activity
import android.content.Context
import android.content.pm.PackageManager
//import androidx.appcompat.app.AppCompatDelegate
//import androidx.core.os.LocaleListCompat
import com.firework.imageloading.ImageLoader
import com.firework.livestream.LivestreamPlayerInitializer
import com.firework.sdk.FireworkSdk
import com.firework.sdk.FireworkSdkConfig
import com.fireworksdk.bridge.models.FWSDKInitOptionsModel
import com.fireworksdk.bridge.models.FWSdkInitResultModel
import com.fireworksdk.bridge.models.enums.FWPlayerLaunchBehavior
import com.fireworksdk.bridge.models.enums.FWSwitchLanguageBehavior
import com.fireworksdk.bridge.utils.FWGlobalDataUtil
import com.fireworksdk.bridge.utils.FWImageLoaderUtil
import com.fireworksdk.bridge.utils.FWLanguageUtil
import com.fireworksdk.bridge.utils.FWLiveStreamUtil
import com.fireworksdk.bridge.utils.FWLogUtils

object FWReactNativeSDK {

  fun closePip() {
    FireworkSdk.closePip()
  }

  /**
   * Sets whether Firework SDK players should mutually mute one another.
   *
   * When enabled (default), unmuting one SDK player may mute other SDK players, and new
   * non-PiP players may start muted while another SDK player is in Picture-in-Picture mode.
   * When disabled, the SDK skips those internal mutual mute rules while keeping Android
   * audio focus handling unchanged.
   *
   * Call from `Application.onCreate()` before or after [init]; the value is honored when
   * the SDK builds its internal audio manager.
   *
   * @param enabled `true` to preserve the default mutual mute behavior, `false` to allow
   * multiple SDK players to remain unmuted at the same time.
   */
  fun setAudioMutualExclusionEnabled(enabled: Boolean) {
    FireworkSdk.setAudioMutualExclusionEnabled(enabled)
  }

  fun init(
    context: Context,
    sdkInitOptions: FWSDKInitOptionsModel? = null,
  ) {
    initSdkInternal(context, sdkInitOptions, onError = {
      FWGlobalDataUtil.sdkInitResultModel = FWSdkInitResultModel(
        success = false,
        reason = it
      )
      FWGlobalDataUtil.initCompletedListener?.invoke()
    }, onSuccess = {
      FWGlobalDataUtil.sdkInitResultModel = FWSdkInitResultModel(
        success = true,
        reason = null
      )
      FWGlobalDataUtil.initCompletedListener?.invoke()
    })
  }

  fun setLanguageSwitchingBehavior(behavior: FWSwitchLanguageBehavior) {
    FWGlobalDataUtil.switchLanguageBehavior = behavior
  }

  fun addLivestreamPlayerInitializer(initializer: LivestreamPlayerInitializer?) {
    FWLiveStreamUtil.addLivestreamPlayerInitializer(initializer)
  }

  fun setImageLoader(imageLoader: ImageLoader?) {
    FWImageLoaderUtil.setImageLoader(imageLoader)
  }

  fun updateBaseContextLocale(context: Context): Context {
    return FWLanguageUtil.getInstance(context).updateBaseContextLocale(context)
  }

  fun changeLanguage(localeString: String?, context: Context): Boolean {
    var newLanguage = localeString
    // switch zh-Hant to zh-HK
    if ("zh-Hant".equals(newLanguage, true)) {
      newLanguage = "zh-HK"
    }
    val isSameLanguageWithCache = FWLanguageUtil.getInstance(context).isSameLanguageWithCache(newLanguage)
    return if (!isSameLanguageWithCache) {
      // execute change language behavior
      val changeLanguageResult = FWLanguageUtil.getInstance(context).changeLanguage(newLanguage)
      if (changeLanguageResult) {
        // change language success, execute rest of logic
        // AppCompatDelegate.setApplicationLocales(LocaleListCompat.forLanguageTags(newLanguage))
        if (context is Activity && FWGlobalDataUtil.switchLanguageBehavior == FWSwitchLanguageBehavior.RestartingActivity) {
          // restart activity
          FWLanguageUtil.getInstance(context).restartActivity(context)
        }
      }
      changeLanguageResult
    } else {
      // no need to change language, return true means change successfully
      true
    }
  }

  fun initSdkInternal(
    context: Context,
    sdkInitOptions: FWSDKInitOptionsModel?,
    onSuccess: (() -> Unit)? = null,
    onError: ((String) -> Unit)? = null
  ) {
    val clientId = getAppid(context)
    if (clientId.isNullOrBlank()) {
      val errorMsg = "The appid is invalid"
      FWLogUtils.d { errorMsg }
      onError?.invoke(errorMsg)
      return
    }


    val configBuilder = FireworkSdkConfig.Builder(context)
      .checksumRequired(false)
      .clientId(clientId)
      .enableCache(true)

    val livestreamPlayerInitializerList = FWLiveStreamUtil.livestreamPlayerInitializers()
    for (livestreamPlayerInitializer in livestreamPlayerInitializerList) {
      configBuilder.addLivestreamPlayerInitializer(livestreamPlayerInitializer)
    }

    when (sdkInitOptions?.videoLaunchBehavior) {
      FWPlayerLaunchBehavior.Default -> {}
      FWPlayerLaunchBehavior.MuteOnFirstLaunch -> {
        configBuilder.muteOnLaunch(true)
      }

      else -> {}
    }

    val imageLoader = FWImageLoaderUtil.getImageLoader()
    if (imageLoader != null) {
      configBuilder.imageLoader(imageLoader)
    }

    val config = configBuilder.build()

    FireworkSdk.init(
      config,
      onSuccess = {
        onSuccess?.invoke()
      },
      onError = { error ->
        onError?.invoke("$error")
      },
    )
  }

  private fun getAppid(context: Context): String? {
    val ai = context.packageManager.getApplicationInfo(
      context.packageName,
      PackageManager.GET_META_DATA
    )
    val value = ai.metaData.get("Firework:Appid")
    return value?.let {
      it as String
    } ?: run {
      null
    }
  }
}