package com.applicaster.oasisplayer.config.oasis

import com.applicaster.oasisplayer.config.PlayableWrapper
import com.applicaster.oasisplayer.config.playable.PlayableConfigParser
import com.applicaster.oasisplayer.config.plugin.PluginConfig
import com.applicaster.oasisplayer.config.plugin.PluginConfigParser
import com.applicaster.oasisplayer.som.SomAdOffsetBuilder
import com.applicaster.oasisplayer.som.SomConfig
import de.prosiebensat1digital.oasisplayer.player_api.ContentOwnerKeys
import de.prosiebensat1digital.oasisplayer.player_api.ContentResource
import de.prosiebensat1digital.oasisplayer.player_api.ContentResourceKeys
import de.prosiebensat1digital.somplugin.SomPlugin

class ContentResourceBuilder {

    fun createFromPlayable(playable: Map<String, Any>): OasisContentResourceWrapper {
        val pluginConfig = getPluginConfig(playable)
        val playableWrapper = getPlayableWrapper(playable)
        val parsedConfig = PlayableConfigParser(pluginConfig).getConfig(playableWrapper)
        val contentResource = mutableMapOf<String, Any>(
                ContentResourceKeys.id to parsedConfig.playableConfig.playableId.orEmpty(),
                ContentResourceKeys.contentType to parsedConfig.playableConfig.contentType.id,
                ContentResourceKeys.title to parsedConfig.playableConfig.title.orEmpty(),

                ContentResourceKeys.contentOwner to hashMapOf(
                        ContentOwnerKeys.name to parsedConfig.playableConfig.playableId
                )
        )

        contentResource.putAll(generateSomConfigMap(parsedConfig.somConfig))
        contentResource.putAll(generateTrackingMetadata(parsedConfig))
        parsedConfig.contentResource = ContentResource(contentResource)
        return parsedConfig
    }

    private fun generateSomConfigMap(somConfig: SomConfig): Map<out String, Any> {
        val somMarketing = hashMapOf(
                SomPlugin.SomMarketingKeys.domain to somConfig.domain,
                SomPlugin.SomMarketingKeys.isLongPlay to somConfig.isLongVideo
        )
        if (somConfig.subdomain != somConfig.domain)
            somMarketing[SomPlugin.SomMarketingKeys.subdomain] = somConfig.subdomain
        return mutableMapOf(
                SomPlugin.ContentResourceKeys.adRollOffsets to SomAdOffsetBuilder().build(somConfig),
                SomPlugin.ContentResourceKeys.somMarketing to somMarketing
        )
    }

    private fun generateTrackingMetadata(parsedConfig: OasisContentResourceWrapper): Map<out String, Any> {
        return when {
            parsedConfig.etAnalyticsConfig.isNotEmpty() -> mutableMapOf(KEY_ET_METADATA to parsedConfig.etAnalyticsConfig)
            else -> mapOf()
        }
    }

    private fun getPlayableWrapper(playable: Map<String, Any>): PlayableWrapper {
        return PlayableWrapper(data = playable, extensions = playable.safelyGetMap(KEY_EXTENSIONS))
    }

    private fun getPluginConfig(playable: Map<String, Any>): PluginConfig=
            PluginConfigParser(playable.safelyGetMap(KEY_PLUGIN_CONFIG)).getPlayerPluginConfig()

    private fun Map<String, Any>.safelyGetMap(key: String): Map<String, Any> {
        return if (containsKey(key))
            (get(key) as? Map<String, Any>).orEmpty()
        else mapOf()
    }

    companion object {
        private const val KEY_ET_METADATA = "trackingMetadata"
        private const val KEY_EXTENSIONS = "extensions"
        private const val KEY_PLUGIN_CONFIG = "pluginConfiguration"
    }
}