package com.blaze.rtnblazesdk.events

import com.blaze.blazesdk.analytics.models.BlazeAnalyticsEvent
import com.blaze.blazesdk.delegates.models.BlazeCTAActionType
import com.blaze.blazesdk.delegates.models.BlazePlayerEvent
import com.blaze.blazesdk.delegates.models.BlazePlayerType
import com.blaze.blazesdk.shared.results.BlazeResult
import com.blaze.rtnblazesdk.utils.KEY_PARAM_PLAYER_EVENT_PARAMS
import com.blaze.rtnblazesdk.utils.KEY_PARAM_PLAYER_EVENT_TYPE
import com.blaze.rtnblazesdk.utils.mapToReact
import com.blaze.rtnblazesdk.utils.toReactEventParams
import com.blaze.rtnblazesdk.utils.toReactEventType
import com.facebook.react.bridge.Arguments
import com.facebook.react.bridge.WritableMap

sealed interface SdkModuleJsEvent {

    val eventName: String
    val params: WritableMap

    data class ErrorThrown(val error: BlazeResult.Error): SdkModuleJsEvent {
        override val eventName = KEY_EVENT_NAME_ERROR_THROWN
        override val params: WritableMap = Arguments.createMap().apply {
            putString(KEY_PARAM_DOMAIN, error.domain.toString())
            putString(KEY_PARAM_REASON, error.reason.toString())
            putString(KEY_PARAM_MESSAGE, error.message)
        }
    }

    data class AnalyticEventTriggered(val eventData: BlazeAnalyticsEvent): SdkModuleJsEvent {
        override val eventName = KEY_EVENT_NAME_EVENT_TRIGGERED
        override val params: WritableMap = Arguments.createMap().apply {
            putString(KEY_PARAM_EVENT_DATA, eventData.asJsonString)
        }
    }

    data class DataLoadCompleted(
        val playerType: BlazePlayerType,
        val sourceId: String?,
        val itemsCount: Int,
        val result: BlazeResult<Unit>
    ): SdkModuleJsEvent {
        override val eventName = KEY_EVENT_NAME_DATA_LOAD_COMPLETED
        override val params: WritableMap = Arguments.createMap().apply {
            putString(KEY_PARAM_PLAYER_TYPE, playerType.mapToReact())
            putString(KEY_PARAM_SOURCE_ID, sourceId)
            putInt(KEY_PARAM_ITEMS_COUNT, itemsCount)
            if (result is BlazeResult.Error) {
                putString(KEY_PARAM_ERROR, result.message ?: "Unknown error")
            }
        }
    }

    data class DataLoadStarted(
        val playerType: BlazePlayerType,
        val sourceId: String?
    ): SdkModuleJsEvent {
        override val eventName = KEY_EVENT_NAME_DATA_LOAD_STARTED
        override val params: WritableMap = Arguments.createMap().apply {
            putString(KEY_PARAM_PLAYER_TYPE, playerType.mapToReact())
            putString(KEY_PARAM_SOURCE_ID, sourceId)
        }
    }

    data class PlayerDidAppear(
        val playerType: BlazePlayerType,
        val sourceId: String?
    ): SdkModuleJsEvent {
        override val eventName = KEY_EVENT_NAME_PLAYER_DID_APPEAR
        override val params: WritableMap = Arguments.createMap().apply {
            putString(KEY_PARAM_PLAYER_TYPE, playerType.mapToReact())
            putString(KEY_PARAM_SOURCE_ID, sourceId)
        }
    }

    data class PlayerDidDismiss(
        val playerType: BlazePlayerType,
        val sourceId: String?
    ): SdkModuleJsEvent {
        override val eventName = KEY_EVENT_NAME_PLAYER_DID_DISMISSED
        override val params: WritableMap = Arguments.createMap().apply {
            putString(KEY_PARAM_PLAYER_TYPE, playerType.mapToReact())
            putString(KEY_PARAM_SOURCE_ID, sourceId)
        }
    }

    data class TriggerCTA(
        val playerType: BlazePlayerType,
        val sourceId: String?,
        val actionType: BlazeCTAActionType,
        val actionParam: String
    ): SdkModuleJsEvent {
        override val eventName = KEY_EVENT_NAME_TRIGGER_CTA
        override val params: WritableMap = Arguments.createMap().apply {
            putString(KEY_PARAM_PLAYER_TYPE, playerType.mapToReact())
            putString(KEY_PARAM_SOURCE_ID, sourceId)
            putString(KEY_PARAM_ACTION_TYPE, actionType.mapToReact())
            putString(KEY_PARAM_ACTION_PARAM, actionParam)
        }
    }

    data class TriggerPlayerBodyTextLink(
        val playerType: BlazePlayerType,
        val sourceId: String?,
        val actionParam: String
    ): SdkModuleJsEvent {
        override val eventName = KEY_EVENT_NAME_TRIGGER_PLAYER_BODY_TEXT_LINK
        override val params: WritableMap = Arguments.createMap().apply {
            putString(KEY_PARAM_PLAYER_TYPE, playerType.mapToReact())
            putString(KEY_PARAM_SOURCE_ID, sourceId)
            putString(KEY_PARAM_ACTION_PARAM, actionParam)
        }
    }

    data class TriggerPlayerEventTriggered(
        val playerType: BlazePlayerType,
        val sourceId: String?,
        val event: BlazePlayerEvent
    ): SdkModuleJsEvent {
        override val eventName = KEY_EVENT_NAME_TRIGGER_PLAYER_EVENT_TRIGGERED
        override val params: WritableMap = Arguments.createMap().apply {
            putString(KEY_PARAM_PLAYER_TYPE, playerType.mapToReact())
            putString(KEY_PARAM_SOURCE_ID, sourceId)
            putString(KEY_PARAM_PLAYER_EVENT_TYPE, event.toReactEventType())
            putString(KEY_PARAM_PLAYER_EVENT_PARAMS, event.toReactEventParams())
        }
    }

    companion object {
        private const val KEY_EVENT_NAME_ERROR_THROWN = "Blaze.onErrorThrown"
        private const val KEY_EVENT_NAME_EVENT_TRIGGERED = "Blaze.onEventTriggered"
        private const val KEY_EVENT_NAME_DATA_LOAD_COMPLETED = "Blaze.onDataLoadComplete"
        private const val KEY_EVENT_NAME_DATA_LOAD_STARTED = "Blaze.onDataLoadStarted"
        private const val KEY_EVENT_NAME_PLAYER_DID_APPEAR = "Blaze.onPlayerDidAppear"
        private const val KEY_EVENT_NAME_PLAYER_DID_DISMISSED = "Blaze.onPlayerDidDismiss"
        private const val KEY_EVENT_NAME_TRIGGER_CTA = "Blaze.onTriggerCTA"
        private const val KEY_EVENT_NAME_TRIGGER_PLAYER_BODY_TEXT_LINK = "Blaze.onTriggerPlayerBodyTextLink"
        private const val KEY_EVENT_NAME_TRIGGER_PLAYER_EVENT_TRIGGERED = "Blaze.onPlayerEventTriggered"

        private const val KEY_PARAM_DOMAIN = "domain"
        private const val KEY_PARAM_REASON = "reason"
        private const val KEY_PARAM_MESSAGE = "message"
        private const val KEY_PARAM_EVENT_DATA = "eventData"
        private const val KEY_PARAM_PLAYER_TYPE = "playerType"
        private const val KEY_PARAM_SOURCE_ID = "sourceId"
        private const val KEY_PARAM_ITEMS_COUNT = "itemsCount"
        private const val KEY_PARAM_ERROR = "error"
        private const val KEY_PARAM_ACTION_TYPE = "actionType"
        private const val KEY_PARAM_ACTION_PARAM = "actionParam"
    }

    fun BlazePlayerType.mapToReact(): String {
        return when (this) {
            BlazePlayerType.MOMENTS -> "Moments"
            BlazePlayerType.STORIES -> "Stories"
            BlazePlayerType.VIDEOS ->  "Videos"
        }
    }

}