package com.connatixplayersdkreactnative

import com.cnx.connatixplayersdk.external.*
import com.cnx.connatixplayersdk.external.EventType.Companion.fromString
import com.cnx.connatixplayersdk.external.VideoQuality.Companion.fromInt
import com.facebook.react.bridge.*
import com.facebook.react.common.MapBuilder
import com.facebook.react.uimanager.SimpleViewManager
import com.facebook.react.uimanager.ThemedReactContext
import com.facebook.react.uimanager.UIManagerHelper
import com.facebook.react.uimanager.common.UIManagerType
import com.facebook.react.uimanager.events.RCTEventEmitter
import kotlinx.serialization.json.Json
import org.json.JSONObject

class ElementsPlayerViewManager(private var context: ReactApplicationContext)
    : SimpleViewManager<ElementsPlayer>() {

    override fun getName() = "RCTElementsPlayer"

    override fun createViewInstance(reactContext: ThemedReactContext): ElementsPlayer {
        val elementsPlayer = ElementsPlayer(reactContext, null)
        elementsPlayer.onPlayerEvent = { onPlayerEvent(it, elementsPlayer.id) }
        return elementsPlayer
    }

    override fun getCommandsMap(): MutableMap<String, Int> {
        val hashMap: MutableMap<String, Int> = HashMap()
        hashMap[SET_ELEMENTS_CONFIG_METHOD] = SET_ELEMENTS_CONFIG_COMMAND
        hashMap[STOP_PLAYER_METHOD] = STOP_PLAYER_COMMAND
        hashMap[PLAY_METHOD] = PLAY_COMMAND
        hashMap[PAUSE_METHOD] = PAUSE_COMMAND
        hashMap[SET_VOLUME_METHOD] = SET_VOLUME_COMMAND
        hashMap[SET_QUALITY_METHOD] = SET_QUALITY_COMMAND
        hashMap[GET_QUALITY_METHOD] = GET_QUALITY_COMMAND
        hashMap[DISABLE_ADVERTISING_METHOD] = DISABLE_ADVERTISING_COMMAND
        hashMap[ENABLE_ADVERTISING_METHOD] = ENABLE_ADVERTISING_COMMAND
        hashMap[SET_MACROS_METHOD] = SET_MACROS_COMMAND
        hashMap[SET_PRE_ROLL_BREAK_METHOD] = SET_PRE_ROLL_BREAK_COMMAND
        hashMap[SET_POST_ROLL_BREAK_METHOD] = SET_POST_ROLL_BREAK_COMMAND
        hashMap[ADD_FRIENDLY_OBSTRUCTION_METHOD] = ADD_FRIENDLY_OBSTRUCTION_COMMAND
        hashMap[REMOVE_FRIENDLY_OBSTRUCTION_METHOD] = REMOVE_FRIENDLY_OBSTRUCTION_COMMAND
        hashMap[GET_VIDEO_DETAILS_METHOD] = GET_VIDEO_DETAILS_COMMAND
        hashMap[GET_VIDEO_CURRENT_POSITION_METHOD] = GET_VIDEO_CURRENT_POSITION_COMMAND
        hashMap[GET_VIDEO_DURATION_METHOD] = GET_VIDEO_DURATION_COMMAND
        hashMap[GET_VIDEO_INDEX_METHOD] = GET_VIDEO_INDEX_COMMAND
        hashMap[SET_VIDEO_INDEX_METHOD] = SET_VIDEO_INDEX_COMMAND
        hashMap[GET_AVAILABLE_QUALITIES_METHOD] = GET_AVAILABLE_QUALITIES_COMMAND
        hashMap[SET_AUTO_QUALITY_METHOD] = SET_AUTO_QUALITY_COMMAND
        hashMap[TOGGLE_FULLSCREEN__METHOD] = TOGGLE_FULLSCREEN_COMMAND
        hashMap[TOGGLE_SUBTITLES_METHOD] = TOGGLE_SUBTITLES_COMMAND
        hashMap[GET_SUBTITLES_METHOD] = GET_SUBTITLES_COMMAND
        hashMap[SET_SUBTITLE_METHOD] = SET_SUBTITLE_COMMAND
        hashMap[LISTEN_FOR_METHOD] = LISTEN_FOR_COMMAND
        hashMap[LISTEN_FOR_MORE_METHOD] = LISTEN_FOR_MORE_COMMAND
        hashMap[LISTEN_FOR_ALL_EVENTS_METHOD] = LISTEN_FOR_ALL_EVENTS_COMMAND
        hashMap[REMOVE_METHOD] = REMOVE_COMMAND
        hashMap[REMOVE_ALL_EVENTS_METHOD] = REMOVE_ALL_EVENTS_COMMAND
        return hashMap
    }

    override fun getExportedCustomBubblingEventTypeConstants(): MutableMap<String, Any> {
        val hashMap: MutableMap<String, Any> = java.util.HashMap()
        hashMap[SET_ELEMENTS_CONFIG_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, SET_ELEMENTS_CONFIG_CALLBACK))
        hashMap[PLAY_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, PLAY_CALLBACK))
        hashMap[PAUSE_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, PAUSE_CALLBACK))
        hashMap[SET_VOLUME_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, SET_VOLUME_CALLBACK))
        hashMap[SET_QUALITY_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, SET_QUALITY_CALLBACK))
        hashMap[GET_QUALITY_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, GET_QUALITY_CALLBACK))
        hashMap[DISABLE_ADVERTISING_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, DISABLE_ADVERTISING_CALLBACK))
        hashMap[ENABLE_ADVERTISING_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, ENABLE_ADVERTISING_CALLBACK))
        hashMap[SET_MACROS_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, SET_MACROS_CALLBACK))
        hashMap[SET_PRE_ROLL_BREAK_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, SET_PRE_ROLL_BREAK_CALLBACK))
        hashMap[SET_POST_ROLL_BREAK_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, SET_POST_ROLL_BREAK_CALLBACK))
        hashMap[ADD_FRIENDLY_OBSTRUCTION_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, ADD_FRIENDLY_OBSTRUCTION_CALLBACK))
        hashMap[REMOVE_FRIENDLY_OBSTRUCTION_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, REMOVE_FRIENDLY_OBSTRUCTION_CALLBACK))
        hashMap[GET_VIDEO_DETAILS_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, GET_VIDEO_DETAILS_CALLBACK))
        hashMap[GET_VIDEO_CURRENT_POSITION_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, GET_VIDEO_CURRENT_POSITION_CALLBACK))
        hashMap[GET_VIDEO_DURATION_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, GET_VIDEO_DURATION_CALLBACK))
        hashMap[GET_VIDEO_INDEX_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, GET_VIDEO_INDEX_CALLBACK))
        hashMap[SET_VIDEO_INDEX_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, SET_VIDEO_INDEX_CALLBACK))
        hashMap[GET_AVAILABLE_QUALITIES_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, GET_AVAILABLE_QUALITIES_CALLBACK))
        hashMap[SET_AUTO_QUALITY_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, SET_AUTO_QUALITY_CALLBACK))
        hashMap[TOGGLE_FULLSCREEN_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, TOGGLE_FULLSCREEN_CALLBACK))
        hashMap[TOGGLE_SUBTITLES_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, TOGGLE_SUBTITLES_CALLBACK))
        hashMap[GET_SUBTITLES_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, GET_SUBTITLES_CALLBACK))
        hashMap[SET_SUBTITLE_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, SET_SUBTITLE_CALLBACK))
        hashMap[LISTEN_FOR_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, LISTEN_FOR_CALLBACK))
        hashMap[LISTEN_FOR_MORE_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, LISTEN_FOR_MORE_CALLBACK))
        hashMap[REMOVE_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, REMOVE_CALLBACK))
        hashMap[ON_PLAYER_EVENT_CALLBACK] = MapBuilder.of(PHASED_REGISTRATION_NAMES, MapBuilder.of(BUBBLED, ON_PLAYER_EVENT_CALLBACK))
        return hashMap
    }

    override fun receiveCommand(root: ElementsPlayer, commandId: Int, args: ReadableArray?) {
        super.receiveCommand(root, commandId, args)
        if (args == null) { return }
        when (commandId) {
            SET_ELEMENTS_CONFIG_COMMAND -> {
                try {
                    val config = args.getString(0)
                    val json = Json { ignoreUnknownKeys = true }
                    val playerConfig: ElementsConfig = json.decodeFromString(config)
                    playerConfig._appSettings.reactNativeSdkVersion = "2.4.10"
                    root.setConfig(playerConfig)
                    invokeCallback(root.id, SET_ELEMENTS_CONFIG_CALLBACK, null, true)
                } catch (exception: Exception) {
                    invokeCallback(root.id, SET_ELEMENTS_CONFIG_CALLBACK, exception.message, null)
                }
            }
            STOP_PLAYER_COMMAND -> root.stopPlayer()
            PLAY_COMMAND -> {
                root.play(object : PlayListener {
                    override fun onException(exception: BaseAPIException) {
                        invokeCallback(root.id, PLAY_CALLBACK, exception.message, null)
                    }
                })
            }
            PAUSE_COMMAND -> {
                root.pause(object : PauseListener {
                    override fun onException(exception: BaseAPIException) {
                        invokeCallback(root.id, PAUSE_CALLBACK, exception.message, null)
                    }
                })
            }
            SET_VOLUME_COMMAND -> {
                try {
                    val volume = args.getDouble(0).toFloat()
                    root.setVolume(volume, object : SetVolumeListener {
                        override fun onException(exception: BaseAPIException) {
                            invokeCallback(root.id, SET_VOLUME_CALLBACK, exception.message, null)
                        }
                    })
                } catch (exception: Exception) {
                    invokeCallback(root.id, SET_VOLUME_CALLBACK, exception.message, null)
                }
            }
            SET_QUALITY_COMMAND -> {
                try {
                    val videoQuality = args.getInt(0)
                    val quality = fromInt(videoQuality)
                    root.setQuality(quality, object : SetQualityListener {
                        override fun onException(exception: BaseAPIException) {
                            invokeCallback(root.id, SET_QUALITY_CALLBACK, exception.message, null)
                        }
                    })
                } catch (exception: Exception) {
                    invokeCallback(root.id, SET_QUALITY_CALLBACK, exception.message, null)
                }
            }
            GET_QUALITY_COMMAND -> {
                root.getQuality(object : GetQualityListener {
                    override fun onResult(videoQuality: VideoQuality) {
                        invokeCallback(root.id, GET_QUALITY_CALLBACK, null, videoQuality.value)
                    }

                    override fun onException(exception: BaseAPIException) {
                        invokeCallback(root.id, GET_QUALITY_CALLBACK, exception.message, null)
                    }
                })
            }
            DISABLE_ADVERTISING_COMMAND -> {
                root.disableAdvertising(object : DisableAdvertisingListener {
                    override fun onException(exception: BaseAPIException) {
                        invokeCallback(root.id, DISABLE_ADVERTISING_CALLBACK, exception.message, null)
                    }
                })
            }
            ENABLE_ADVERTISING_COMMAND -> {
                root.enableAdvertising(object : EnableAdvertisingListener {
                    override fun onException(exception: BaseAPIException) {
                        invokeCallback(root.id, ENABLE_ADVERTISING_CALLBACK, exception.message, null)
                    }
                })
            }
            SET_MACROS_COMMAND -> {
                try {
                    val macrosJsonString = args.getString(0)
                    val macros = JSONObject(macrosJsonString)
                    root.setMacros(macros, object : SetMacrosListener {
                        override fun onException(exception: BaseAPIException) {
                            invokeCallback(root.id, SET_MACROS_CALLBACK, exception.message, null)
                        }
                    })
                } catch (exception: Exception) {
                    invokeCallback(root.id, SET_MACROS_CALLBACK, exception.message, null)
                }
            }
            SET_PRE_ROLL_BREAK_COMMAND -> {
                try {
                    val seconds = args.getInt(0)
                    root.setPreRollBreak(seconds, object : SetPreRollBreakListener {
                        override fun onException(exception: BaseAPIException) {
                            invokeCallback(root.id, SET_PRE_ROLL_BREAK_CALLBACK, exception.message, null)
                        }
                    })
                } catch (exception: Exception) {
                    invokeCallback(root.id, SET_PRE_ROLL_BREAK_CALLBACK, exception.message, null)
                }
            }
            SET_POST_ROLL_BREAK_COMMAND -> {
                try {
                    val seconds = args.getInt(0)
                    root.setPostRollBreak(seconds, object : SetPostRollBreakListener {
                        override fun onException(exception: BaseAPIException) {
                            invokeCallback(root.id, SET_POST_ROLL_BREAK_CALLBACK, exception.message, null)
                        }
                    })
                } catch (exception: Exception) {
                    invokeCallback(root.id, SET_POST_ROLL_BREAK_CALLBACK, exception.message, null)
                }
            }
            ADD_FRIENDLY_OBSTRUCTION_COMMAND -> {
                try {
                    val obstructionReactTag = args.getInt(0)
                    val purpose = args.getString(1).toObstructionPurpose()
                    val detailedReason = args.getString(2)
                    UIManagerHelper.getUIManager(context, UIManagerType.DEFAULT)?.resolveView(obstructionReactTag)?.let { obstructionView ->
                        root.addFriendlyObstruction(obstructionView, purpose, detailedReason, object : AddFriendlyObstructionListener {
                            override fun onException(exception: BaseAPIException) {
                                invokeCallback(root.id, ADD_FRIENDLY_OBSTRUCTION_CALLBACK, exception.message, null)
                            }
                        })
                    }
                } catch (exception: Exception) {
                    invokeCallback(root.id, ADD_FRIENDLY_OBSTRUCTION_CALLBACK, exception.message, null)
                }
            }
            REMOVE_FRIENDLY_OBSTRUCTION_COMMAND -> {
                try {
                    val obstructionReactTag = args.getInt(0)
                    UIManagerHelper.getUIManager(context, UIManagerType.DEFAULT)?.resolveView(obstructionReactTag)?.let { obstructionView ->
                        root.removeFriendlyObstruction(obstructionView, object : RemoveFriendlyObstructionListener {
                            override fun onException(exception: BaseAPIException) {
                                invokeCallback(root.id, REMOVE_FRIENDLY_OBSTRUCTION_CALLBACK, exception.message, null)
                            }
                        })
                    }
                } catch (exception: Exception) {
                    invokeCallback(root.id, REMOVE_FRIENDLY_OBSTRUCTION_CALLBACK, exception.message, null)
                }
            }
            GET_VIDEO_DETAILS_COMMAND -> {
                root.getVideoDetails(object : GetVideoDetailsListener {
                    override fun onResult(videoDetails: VideoDescription) {
                        val dictionary = Arguments.createMap()
                        dictionary.putString(VideoDetailsKeys.DESCRIPTION, videoDetails.description)
                        dictionary.putDouble(VideoDetailsKeys.DURATION, videoDetails.duration)
                        dictionary.putString(VideoDetailsKeys.ID, videoDetails.id)
                        val keywords = videoDetails.keywords
                        val keywordsBridged = Arguments.createArray()
                        var index = 0
                        while (index < keywords.size) {
                            keywordsBridged.pushString(keywords[index])
                            index++
                        }
                        dictionary.putArray(VideoDetailsKeys.KEYWORDS, keywordsBridged)
                        dictionary.putString(VideoDetailsKeys.TITLE, videoDetails.title)
                        dictionary.putString(VideoDetailsKeys.URL, videoDetails.url)
                        invokeCallback(root.id, GET_VIDEO_DETAILS_CALLBACK, null, dictionary)
                    }

                    override fun onException(exception: ElementsAPIException) {
                        invokeCallback(root.id, GET_VIDEO_DETAILS_CALLBACK, exception.message, null)
                    }
                })
            }
            GET_VIDEO_CURRENT_POSITION_COMMAND -> {
                root.getVideoCurrentPosition(object : GetVideoCurrentPositionListener {
                    override fun onResult(videoCurrentPosition: Double) {
                        invokeCallback(root.id, GET_VIDEO_CURRENT_POSITION_CALLBACK, null, videoCurrentPosition)
                    }

                    override fun onException(exception: ElementsAPIException) {
                        invokeCallback(root.id, GET_VIDEO_CURRENT_POSITION_CALLBACK, exception.message, null)
                    }
                })
            }
            GET_VIDEO_DURATION_COMMAND -> {
                root.getVideoDuration(object : GetVideoDurationListener {
                    override fun onResult(videoDuration: Double) {
                        invokeCallback(root.id, GET_VIDEO_DURATION_CALLBACK, null, videoDuration)
                    }

                    override fun onException(exception: ElementsAPIException) {
                        invokeCallback(root.id, GET_VIDEO_DURATION_CALLBACK, exception.message, null)
                    }
                })
            }
            GET_VIDEO_INDEX_COMMAND -> {
                root.getVideoIndex(object : GetVideoIndexListener {
                    override fun onResult(index: Int) {
                        invokeCallback(root.id, GET_VIDEO_INDEX_CALLBACK, null, index)
                    }

                    override fun onException(exception: ElementsAPIException) {
                        invokeCallback(root.id, GET_VIDEO_INDEX_CALLBACK, exception.message, null)
                    }
                })
            }
            SET_VIDEO_INDEX_COMMAND -> {
                try {
                    val index = args.getInt(0)
                    root.setVideoIndex(index, object : SetVideoIndexListener {
                        override fun onException(exception: ElementsAPIException) {
                            invokeCallback(root.id, SET_VIDEO_INDEX_CALLBACK, exception.message, null)
                        }
                    })
                } catch (exception: Exception) {
                    invokeCallback(root.id, SET_VIDEO_INDEX_CALLBACK, exception.message, null)
                }
            }
            GET_AVAILABLE_QUALITIES_COMMAND -> {
                root.getAvailableQualities(object : GetVideoAvailableQualitiesListener {
                    override fun onResult(videoAvailableQualities: List<VideoQuality>) {
                        val videoQualitiesInt = Arguments.createArray()
                        var index = 0
                        while (index < videoAvailableQualities.size) {
                            videoQualitiesInt.pushInt(videoAvailableQualities[index].value)
                            index++
                        }
                        invokeCallback(root.id, GET_AVAILABLE_QUALITIES_CALLBACK, null, videoQualitiesInt)
                    }

                    override fun onException(exception: ElementsAPIException) {
                        invokeCallback(root.id, GET_AVAILABLE_QUALITIES_CALLBACK, exception.message, null)
                    }
                })
            }
            SET_AUTO_QUALITY_COMMAND -> {
                root.setAutoQuality(object : SetAutoQualityListener {
                    override fun onException(exception: ElementsAPIException) {
                        invokeCallback(root.id, SET_AUTO_QUALITY_CALLBACK, exception.message, null)
                    }
                })
            }
            TOGGLE_FULLSCREEN_COMMAND -> {
                root.toggleFullScreen(object : ToggleFullscreenListener {
                    override fun onException(exception: ElementsAPIException) {
                        invokeCallback(root.id, TOGGLE_FULLSCREEN_CALLBACK, exception.message, null)
                    }
                })
            }
            TOGGLE_SUBTITLES_COMMAND -> {
                try {
                    val shouldShow = args.getBoolean(0)
                    root.toggleSubtitles(shouldShow, object : ToggleSubtitlesListener {
                        override fun onException(exception: ElementsAPIException) {
                            invokeCallback(root.id, TOGGLE_SUBTITLES_CALLBACK, exception.message, null)
                        }
                    })
                } catch (exception: Exception) {
                    invokeCallback(root.id, TOGGLE_SUBTITLES_CALLBACK, exception.message, null)
                }
            }
            GET_SUBTITLES_COMMAND -> {
                root.getSubtitles(object : GetSubtitlesListener {
                    override fun onResult(tracks: List<Track>) {
                        val result = Arguments.createArray()
                        var index = 0
                        while (index < tracks.size) {
                            val dictionary = Arguments.createMap()
                            val (file, type, code, title) = tracks[index]
                            dictionary.putString(TrackKeys.FILE, file)
                            if (type != null) {
                                dictionary.putInt(TrackKeys.TYPE, type.value)
                            }
                            dictionary.putString(TrackKeys.CODE, code)
                            dictionary.putString(TrackKeys.TITLE, title)
                            result.pushMap(dictionary)
                            index++
                        }
                        invokeCallback(root.id, GET_SUBTITLES_CALLBACK, null, result)
                    }

                    override fun onException(exception: ElementsAPIException) {
                        invokeCallback(root.id, GET_SUBTITLES_CALLBACK, exception.message, null)
                    }
                })
            }
            SET_SUBTITLE_COMMAND -> {
                try {
                    val trackJsonString = args.getString(0)
                    val json = Json { ignoreUnknownKeys = true }
                    val track: Track = json.decodeFromString(trackJsonString)
                    root.setSubtitle(track, object : SetSubtitleListener {
                        override fun onException(exception: ElementsAPIException) {
                            invokeCallback(root.id, SET_SUBTITLE_CALLBACK, exception.message, null)
                        }
                    })
                } catch (exception: Exception) {
                    invokeCallback(root.id, SET_SUBTITLE_CALLBACK, exception.message, null)
                }
            }
            LISTEN_FOR_COMMAND -> {
                try {
                    val event = args.getString(0)
                    val once = args.getBoolean(1)
                    val eventType = fromString(event)
                    root.listenFor(eventType, once)
                } catch (exception: Exception) {
                    invokeCallback(root.id, LISTEN_FOR_CALLBACK, exception.message, null)
                }
            }
            LISTEN_FOR_MORE_COMMAND -> {
                try {
                    val events = args.getArray(0)
                    val eventsToListenTo = ArrayList<EventType>()
                    var index = 0
                    while (index < events.size()) {
                        val event = events.getString(index)
                        val eventType = fromString(event)
                        eventsToListenTo.add(eventType)
                        index++
                    }
                    root.listenForMore(eventsToListenTo)
                } catch (exception: Exception) {
                    invokeCallback(root.id, LISTEN_FOR_MORE_CALLBACK, exception.message, null)
                }
            }
            LISTEN_FOR_ALL_EVENTS_COMMAND -> {
                root.listenForAllEvents()
            }
            REMOVE_COMMAND -> {
                try {
                    val event = args.getString(0)
                    val eventType = fromString(event)
                    root.remove(eventType)
                } catch (exception: Exception) {
                    invokeCallback(root.id, REMOVE_CALLBACK, exception.message, null)
                }
            }
            REMOVE_ALL_EVENTS_COMMAND -> {
                root.removeAllEvents()
            }
        }
    }

    private fun invokeCallback(viewId: Int, callbackName: String, errorMessage: String?, result: Any?) {
        val map = Arguments.createMap()
        if (errorMessage != null) {
            map.putString(ERROR_KEY, errorMessage)
            context.getJSModule(RCTEventEmitter::class.java).receiveEvent(viewId, callbackName, map)
            return
        }
        if (result is Boolean) {
            map.putBoolean(RESULT_KEY, (result as Boolean?)!!)
            context.getJSModule(RCTEventEmitter::class.java).receiveEvent(viewId, callbackName, map)
            return
        }
        if (result is Int) {
            map.putInt(RESULT_KEY, (result as Int?)!!)
            context.getJSModule(RCTEventEmitter::class.java).receiveEvent(viewId, callbackName, map)
            return
        }
        if (result is Double) {
            map.putDouble(RESULT_KEY, (result as Double?)!!)
            context.getJSModule(RCTEventEmitter::class.java).receiveEvent(viewId, callbackName, map)
            return
        }
        if (result is ReadableArray) {
            map.putArray(RESULT_KEY, result as ReadableArray?)
            context.getJSModule(RCTEventEmitter::class.java).receiveEvent(viewId, callbackName, map)
            return
        }
        if (result is ReadableMap) {
            map.putMap(RESULT_KEY, result as ReadableMap?)
            context.getJSModule(RCTEventEmitter::class.java).receiveEvent(viewId, callbackName, map)
            return
        }
        if (result is String) {
            map.putString(RESULT_KEY, result as String?)
            context.getJSModule(RCTEventEmitter::class.java).receiveEvent(viewId, callbackName, map)
        }
    }

    private fun onPlayerEvent(playerEvent: PlayerEvent, viewId: Int) {
        val key = playerEvent.component1().value
        val payload = playerEvent.component2()
        val params = Arguments.createMap()
        val readableMap: ReadableMap = Arguments.makeNativeMap(payload)
        params.putMap(key, readableMap)
        context.getJSModule(RCTEventEmitter::class.java).receiveEvent(viewId, ON_PLAYER_EVENT_CALLBACK, params)
    }

    private fun String.toObstructionPurpose(): ObstructionPurpose {
        when (this) {
            "videoControls" -> return ObstructionPurpose.VIDEO_CONTROLS
            "closeAd" -> return ObstructionPurpose.CLOSE_AD
            "notVisible" -> return ObstructionPurpose.NOT_VISIBLE
        }
        return ObstructionPurpose.OTHER
    }

    companion object {

        internal object VideoDetailsKeys {
            const val DESCRIPTION = "description"
            const val DURATION = "duration"
            const val ID = "id"
            const val KEYWORDS = "keywords"
            const val TITLE = "title"
            const val URL = "url"
        }

        internal object TrackKeys {
            const val FILE = "file"
            const val TYPE = "type"
            const val CODE = "code"
            const val TITLE = "title"
        }

        private const val PHASED_REGISTRATION_NAMES = "phasedRegistrationNames"
        private const val BUBBLED = "bubbled"

        private const val ERROR_KEY = "error"
        private const val RESULT_KEY = "result"

        private const val SET_ELEMENTS_CONFIG_METHOD = "setElementsConfig"
        private const val SET_ELEMENTS_CONFIG_CALLBACK = "onSetElementsConfig"
        private const val SET_ELEMENTS_CONFIG_COMMAND = 6000

        private const val STOP_PLAYER_METHOD = "stopPlayer"
        private const val STOP_PLAYER_COMMAND = 6001

        private const val PLAY_METHOD = "play"
        private const val PLAY_CALLBACK = "onPlay"
        private const val PLAY_COMMAND = 6002

        private const val PAUSE_METHOD = "pause"
        private const val PAUSE_CALLBACK = "onPause"
        private const val PAUSE_COMMAND = 6003

        private const val SET_VOLUME_METHOD = "setVolume"
        private const val SET_VOLUME_CALLBACK = "onSetVolume"
        private const val SET_VOLUME_COMMAND = 6004

        private const val SET_QUALITY_METHOD = "setQuality"
        private const val SET_QUALITY_CALLBACK = "onSetQuality"
        private const val SET_QUALITY_COMMAND = 6005

        private const val GET_QUALITY_METHOD = "getQuality"
        private const val GET_QUALITY_CALLBACK = "onGetQuality"
        private const val GET_QUALITY_COMMAND = 6006

        private const val DISABLE_ADVERTISING_METHOD = "disableAdvertising"
        private const val DISABLE_ADVERTISING_CALLBACK = "onDisableAdvertising"
        private const val DISABLE_ADVERTISING_COMMAND = 6007

        private const val ENABLE_ADVERTISING_METHOD = "enableAdvertising"
        private const val ENABLE_ADVERTISING_CALLBACK = "onEnableAdvertising"
        private const val ENABLE_ADVERTISING_COMMAND = 6008

        private const val SET_MACROS_METHOD = "setMacros"
        private const val SET_MACROS_CALLBACK = "onSetMacros"
        private const val SET_MACROS_COMMAND = 6009

        private const val SET_PRE_ROLL_BREAK_METHOD = "setPreRollBreak"
        private const val SET_PRE_ROLL_BREAK_CALLBACK = "onSetPreRollBreak"
        private const val SET_PRE_ROLL_BREAK_COMMAND = 6010

        private const val SET_POST_ROLL_BREAK_METHOD = "setPostRollBreak"
        private const val SET_POST_ROLL_BREAK_CALLBACK = "onSetPostRollBreak"
        private const val SET_POST_ROLL_BREAK_COMMAND = 6011

        private const val ADD_FRIENDLY_OBSTRUCTION_METHOD = "addFriendlyObstruction"
        private const val ADD_FRIENDLY_OBSTRUCTION_CALLBACK = "onAddFriendlyObstruction"
        private const val ADD_FRIENDLY_OBSTRUCTION_COMMAND = 6012

        private const val REMOVE_FRIENDLY_OBSTRUCTION_METHOD = "removeFriendlyObstruction"
        private const val REMOVE_FRIENDLY_OBSTRUCTION_CALLBACK = "onRemoveFriendlyObstruction"
        private const val REMOVE_FRIENDLY_OBSTRUCTION_COMMAND = 6013

        private const val GET_VIDEO_DETAILS_METHOD = "getVideoDetails"
        private const val GET_VIDEO_DETAILS_CALLBACK = "onGetVideoDetails"
        private const val GET_VIDEO_DETAILS_COMMAND = 7000

        private const val GET_VIDEO_CURRENT_POSITION_METHOD = "getVideoCurrentPosition"
        private const val GET_VIDEO_CURRENT_POSITION_CALLBACK = "onGetVideoCurrentPosition"
        private const val GET_VIDEO_CURRENT_POSITION_COMMAND = 7001

        private const val GET_VIDEO_DURATION_METHOD = "getVideoDuration"
        private const val GET_VIDEO_DURATION_CALLBACK = "onGetVideoDuration"
        private const val GET_VIDEO_DURATION_COMMAND = 7002

        private const val GET_VIDEO_INDEX_METHOD = "getVideoIndex"
        private const val GET_VIDEO_INDEX_CALLBACK = "onGetVideoIndex"
        private const val GET_VIDEO_INDEX_COMMAND = 7009

        private const val SET_VIDEO_INDEX_METHOD = "setVideoIndex"
        private const val SET_VIDEO_INDEX_CALLBACK = "onSetVideoIndex"
        private const val SET_VIDEO_INDEX_COMMAND = 7010

        private const val SET_AUTO_QUALITY_METHOD = "setAutoQuality"
        private const val SET_AUTO_QUALITY_CALLBACK = "onSetAutoQuality"
        private const val SET_AUTO_QUALITY_COMMAND = 7003

        private const val GET_AVAILABLE_QUALITIES_METHOD = "getAvailableQualities"
        private const val GET_AVAILABLE_QUALITIES_CALLBACK = "onGetAvailableQualities"
        private const val GET_AVAILABLE_QUALITIES_COMMAND = 7004

        private const val TOGGLE_FULLSCREEN__METHOD = "toggleFullscreen"
        private const val TOGGLE_FULLSCREEN_CALLBACK = "onToggleFullscreen"
        private const val TOGGLE_FULLSCREEN_COMMAND = 7005

        private const val TOGGLE_SUBTITLES_METHOD = "toggleSubtitles"
        private const val TOGGLE_SUBTITLES_CALLBACK = "onToggleSubtitles"
        private const val TOGGLE_SUBTITLES_COMMAND = 7006

        private const val GET_SUBTITLES_METHOD = "getSubtitles"
        private const val GET_SUBTITLES_CALLBACK = "onGetSubtitles"
        private const val GET_SUBTITLES_COMMAND = 7007

        private const val SET_SUBTITLE_METHOD = "setSubtitle"
        private const val SET_SUBTITLE_CALLBACK = "onSetSubtitle"
        private const val SET_SUBTITLE_COMMAND = 7008

        private const val LISTEN_FOR_METHOD = "listenFor"
        private const val LISTEN_FOR_CALLBACK = "onListenFor"
        private const val LISTEN_FOR_COMMAND = 9000

        private const val LISTEN_FOR_MORE_METHOD = "listenForMore"
        private const val LISTEN_FOR_MORE_CALLBACK = "onListenForMore"
        private const val LISTEN_FOR_MORE_COMMAND = 9001

        private const val LISTEN_FOR_ALL_EVENTS_METHOD = "listenForAllEvents"
        private const val LISTEN_FOR_ALL_EVENTS_COMMAND = 9002

        private const val REMOVE_METHOD = "remove"
        private const val REMOVE_CALLBACK = "onRemove"
        private const val REMOVE_COMMAND = 9003

        private const val REMOVE_ALL_EVENTS_METHOD = "removeAllEvents"
        private const val REMOVE_ALL_EVENTS_COMMAND = 9004

        private const val ON_PLAYER_EVENT_CALLBACK = "onPlayerEvent"
    }
}