package com.applicaster.oasisplayer.config.playable

import com.applicaster.oasisplayer.config.oasis.OasisContentResourceWrapper
import com.applicaster.oasisplayer.config.PlayableWrapper
import com.applicaster.oasisplayer.config.plugin.PluginConfig
import com.applicaster.oasisplayer.som.SomConfigParser
import com.applicaster.oasisplayer.tracker.EtAnalyticsConfigParser

class PlayableConfigParser(private val pluginConfig: PluginConfig?) {
    internal fun getConfig(playableWrapper: PlayableWrapper): OasisContentResourceWrapper {
        val playableConfig = getPlayableConfig(playableWrapper)
        return OasisContentResourceWrapper(
                contentResource = null,
                playableConfig = playableConfig,
                somConfig = SomConfigParser(pluginConfig).getSomConfig(playableWrapper.extensions),
                etAnalyticsConfig = EtAnalyticsConfigParser().getConfig(playableWrapper.extensions),
                playerConfigId = playableConfig.parsedPlayerConfigId ?: pluginConfig?.configId
        )
    }

    private fun getPlayableConfig(playableWrapper: PlayableWrapper): PlayableConfig {
        val isLife = playableWrapper.data.isLife()
        val playable = playableWrapper.data
        val playableExtensions = playableWrapper.extensions
        val streamCountryData = getStreamCountryMap(playableExtensions)
        val streamCountry = streamCountryData.first
        val streamDataMap = streamCountryData.second ?: mapOf()
        return PlayableConfig(
                parsedPlayerConfigId = getPlayerConfigId(streamDataMap),
                playableId = if (isLife) getLiveVideoId(playableWrapper, streamDataMap) else playable[KEY_CLIP_ID] as String,
                clipId = getChannelId(playableExtensions),
                contentType = if (isLife) PlayableContentType.LIVE else PlayableContentType.VOD,
                title = playable[KEY_TITLE] as? String,
                desc = null,
                streamCountry = streamCountry
        )
    }

    private fun Map<String, Any>.isLife(): Boolean {
        val type = this[KEY_TYPE] as? Map<String, Any>
        val value = type?.get(KEY_VALUE) as? String
        return value != KEY_VIDEO
    }

    private fun getStreamCountryMap(extensions: Map<String, Any>): Pair<String?, Map<String, Any>?> {
        var country: String? = null
        var dataMap: Map<String, Any>? = null
        if (extensions.containsKey(KEY_STREAMS)) {
            val streamCountryData = extensions[KEY_STREAMS] as? Map<String, List<Map<String, Any>>>
            streamCountryData?.let {
                country = it.keys.elementAt(0) as? String?
                if (it.containsKey(country.orEmpty())) {
                    dataMap = it[country]?.get(0)
                }
            }
        }
        return Pair(country, dataMap)
    }

    private fun getLiveVideoId(
            playableWrapper: PlayableWrapper,
            streamDataMap: Map<String, Any>
    ): String {
        val idFromExtensions = getClipId(streamDataMap)
        return if (idFromExtensions.isNullOrEmpty()) {
            val idFromPlayable = extractChannelIdFromPlayable(playableWrapper)
            if (idFromPlayable.isNullOrEmpty())
                getClipId(playableWrapper.data).orEmpty()
            else
                idFromPlayable
        } else {
            idFromExtensions
        }
    }

    private fun extractChannelIdFromPlayable(playableWrapper: PlayableWrapper): String? {
            val channelId = playableWrapper.extensions[KEY_CHANNEL_BRANDING] as String?
            return if (channelId.isNullOrEmpty()) {
                getClipId(playableWrapper.data)
            } else
                channelId

    }

    private fun getClipId(extensions: Map<*, *>): String? {
        if (extensions.containsKey(KEY_CLIP_ID)) {
            return (extensions[KEY_CLIP_ID] as? String)
        }
        return null
    }

    private fun getChannelId(extensions: Map<*, *>): String? {
        if (extensions.containsKey(KEY_CHANNEL_ID)) {
            return (extensions[KEY_CHANNEL_ID] as? Double)?.toInt().toString()
        }
        return null
    }

    private fun getPlayerConfigId(extensions: Map<*, *>): String? {
        if (extensions.containsKey(KEY_PLAYER_CONFIG)) {
            val playerConfigWrapper = extensions[KEY_PLAYER_CONFIG] as? Map<*, *>
            return playerConfigWrapper?.let {
                if (it.containsKey(KEY_PLAYER_CONFIG_ID))
                    it[KEY_PLAYER_CONFIG_ID] as? String
                else null
            }
        }
        return null
    }

    companion object {
        const val KEY_PLAYER_CONFIG = "playerConfig"
        const val KEY_STREAMS = "streams"
        const val KEY_PLAYER_CONFIG_ID = "id"
        const val KEY_CLIP_ID = "id"
        const val KEY_TITLE = "title"
        const val KEY_CHANNEL_BRANDING = "channel_branding"
        const val KEY_CHANNEL_ID = "channel_id"
        const val KEY_TYPE = "type"
        const val KEY_VALUE = "value"
        const val KEY_VIDEO = "video"
    }
}