package com.applicaster.easytracking

import android.app.Activity
import android.content.Context
import android.util.Log
import com.applicaster.analytics.BaseAnalyticsAgent
import com.applicaster.app.CustomApplication
import com.applicaster.easytracking.config.player.ApplicasterAnalyticsParams
import com.applicaster.easytracking.config.player.AnalyticsParamsParser
import com.applicaster.easytracking.config.player.PlayerAnalyticsParams
import com.applicaster.easytracking.config.plugin.EasyTrackingPluginConfig
import com.applicaster.easytracking.config.plugin.PluginConfigParser
import com.applicaster.easytracking.ivw.IVWCodeMapper
import com.applicaster.easytracking.ivw.IVWConfigParser
import de.prosiebensat1.easytracking.*
import de.prosiebensat1.easytracking.googleanalytics.GoogleAnalyticsTracker
import de.prosiebensat1.easytracking.infonline.IVWTracker
import de.prosiebensat1.easytracking.infonline.OewaTracker
import de.prosiebensat1.easytracking.mixpanel.MixpanelTracker
import de.prosiebensat1.easytracking.nielsen.NielsenTracker
import de.prosiebensat1.easytracking.nurago.NuragoTracker
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.launch
import java.util.*

class EasyTrackingAnalyticsAgent : BaseAnalyticsAgent() {

    private var ivwCodeMapper: IVWCodeMapper? = null
    private var appContext: Context? = null

    override fun initializeAnalyticsAgent(context: Context?) {
        super.initializeAnalyticsAgent(context)
        appContext = context?.applicationContext

        context?.let {
            ScreenEventBroadcastsListener(it, this)
        }
    }

    override fun setParams(params: MutableMap<Any?, Any?>?) {
        super.setParams(params)
        val pluginConfig = PluginConfigParser(
                params
        ).getConfig()
        initTracker(pluginConfig)
        initIVWMapper(pluginConfig.ivwConfigJson)
    }

    private fun initTracker(pluginConfig: EasyTrackingPluginConfig) {
        appContext?.let {
            val trackers = listOf(
                    EchoTracker("googleAnalytics"),
                    GoogleAnalyticsTracker(it),
                    IVWTracker(it),
                    OewaTracker(it),
                    NielsenTracker(it),
                    NuragoTracker(it),
                    MixpanelTracker(it)
            )

            GlobalScope.launch {
                try {
                    EasyTracker.setup(
                            pluginConfig.clientId.orEmpty(),
                            it,
                            trackers
                    ) { error: EasyTrackerError ->
                        Log.e("EasyTracker", "error: $error")
                    }
                    EasyTracker.setDebug(BuildConfig.DEBUG)
                    EasyTracker.enable()
                } catch (t: Throwable) {
                    Log.e("EasyTracker", "Setup error: $t")
                }
            }
        }
    }

    private fun initIVWMapper(ivwConfigJson: String?) {
        if (ivwConfigJson != null && ivwConfigJson.isNotEmpty()) {
            val events = IVWConfigParser().parse(ivwConfigJson)
            ivwCodeMapper = IVWCodeMapper(events.values)
        }
    }

    override fun analyticsSwitch(enabled: Boolean) {
        super.analyticsSwitch(enabled)
        if (enabled)
            EasyTracker.enable()
        else
            EasyTracker.disable()
    }

    override fun logEvent(eventName: String?, params: TreeMap<String, String>?) {
        super.logEvent(eventName, params)

        when (val config = AnalyticsParamsParser(params).getConfig()) {
            is PlayerAnalyticsParams -> {
                Log.d("EasyTacking", "trackMediaEvent $eventName | params: ${config.jsonData}")
                EasyTracker.trackMediaEvent(eventName ?: "Unknown event name", config.jsonData)
            }
            is ApplicasterAnalyticsParams -> {
                val modifiedEvent = ivwCodeMapper?.mapAction(eventName.orEmpty(), config.analyticsEvents)
                if (modifiedEvent != null) {
                    Log.d("EasyTacking", "trackEvent with IVW $modifiedEvent")
                    EasyTracker.trackEvent(modifiedEvent.name, modifiedEvent.params)
                } else {
                    Log.d("EasyTacking", "trackEvent $eventName | params: ${config.analyticsEvents}")
                    EasyTracker.trackEvent(eventName
                            ?: "Unknown event name", config.analyticsEvents)
                }
            }
        }
    }

    override fun logEvent(eventName: String?) {
        super.logEvent(eventName)
        EasyTracker.trackEvent(eventName ?: "Unknown event name", mapOf())
    }

    override fun setScreenView(activity: Activity?, screenView: String?) {
        super.setScreenView(activity, screenView)
        val modifiedEvent = ivwCodeMapper?.mapScreen(screenView.orEmpty())
        if (modifiedEvent != null) {
            Log.d("EasyTacking", "trackScreen with IVW $modifiedEvent")
            EasyTracker.trackScreen(modifiedEvent.name, modifiedEvent.params)
        } else {
            Log.d("EasyTacking", "trackScreen $screenView")
            EasyTracker.trackScreen(screenView ?: "Unknown screen view", mapOf())
        }
    }
}