InAppChat.getInstance(context).activate()

InAppChat.getInstance(context).inAppChatScreen().show()

class MainActivity: AppCompatActivity(), InAppChatFragment.InAppChatActionBarProvider {

    /* InAppChatActionBarProvider */

    /**
     * Provide the original ActionBar to give the in-app chat ability to hide it and use its own ActionBar.
     * It will be hidden when an in-app Chat fragment is shown and returned back when an in-app Chat fragment hidden.
     */
    override val originalSupportActionBar: ActionBar?
        get() = supportActionBar

    /**
     * Implement a back button behaviour.
     * Call the following method with a corresponding parameter:
     * {@link InAppChat#hideInAppChatFragment(FragmentManager)}
     */
    override fun onInAppChatBackPressed() {
        InAppChat.getInstance(this).hideInAppChatFragment(supportFragmentManager)
        //you can pass "true" as second argument to disconnect chat when fragment is hidden to receive push notifications
        //InAppChat.getInstance(this).hideInAppChatFragment(supportFragmentManager, true)
    }
...
}

class MainActivity: AppCompatActivity() {

    lateinit var fragment: InAppChatFragment

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        //1. Create instance and set UI components visibility
        fragment = InAppChatFragment()
        fragment.withInput = false
        fragment.withToolbar = true
        
        //2. Set events listener
        fragment.eventsListener = object : InAppChatFragment.EventsListener {

            override fun onChatLoadingFinished(result: LivechatWidgetResult<Unit>) {
                //Chat has been loaded and connection established.
            }

            override fun onChatConnectionPaused(result: LivechatWidgetResult<Unit>) {
                //Chat connection has been paused.
            }

            override fun onChatConnectionResumed(result: LivechatWidgetResult<Unit>) {
                //Chat connection has been resumed.
            }

            override fun onChatContextualDataSent(result: LivechatWidgetResult<String?>) {
                //Called when chat contextual data are sent.
            }

            override fun onChatSent(result: LivechatWidgetResult<LivechatWidgetMessage?>) {
                //Called when chat message was sent.
            }

            override fun onChatThreadsReceived(result: LivechatWidgetResult<LivechatWidgetThreads>) {
                //Called when chat threads were requested.
            }

            override fun onChatThreadCreated(result: LivechatWidgetResult<LivechatWidgetMessage?>) {
                //Called when chat thread was created.
            }

            override fun onChatActiveThreadReceived(result: LivechatWidgetResult<LivechatWidgetThread?>) {
                //Called when chat active thread was requested.
                //Success result can contains null if there is no existing thread for current user session or current widget destination is not [LivechatWidgetView.THREAD].
            }

            override fun onChatThreadShown(result: LivechatWidgetResult<LivechatWidgetThread>) {
                //Called when chat thread is shown.
            }

            override fun onChatThreadListShown(result: LivechatWidgetResult<Unit>) {
                //Called when chat thread list is shown.
            }

            override fun onChatLanguageChanged(result: LivechatWidgetResult<String?>) {
                //Called when chat language has been changed.
            }

            override fun onChatWidgetThemeChanged(result: LivechatWidgetResult<String?>) {
                //Called when chat theme has been changed.
            }

            override fun onChatControlsVisibilityChanged(isVisible: Boolean) {
                //Chat controls visibility has changed.
            }

            override fun onChatViewChanged(widgetView: LivechatWidgetView) {
                //Chat view has changed.
            }

            override fun onChatWidgetInfoUpdated(widgetInfo: WidgetInfo) {
                //Chat [WidgetInfo] has been updated.
            }

            override fun onChatRawMessageReceived(rawMessage: String) {
                //Chat message has been received.
            }

            override fun onChatAttachmentPreviewOpened(
                url: String?,
                type: String?,
                caption: String?
            ): Boolean {
                //Called when attachment from chat has been interacted.
                //It allows you to handle attachment preview on your own. Return true if you handled attachment preview.
                //Return false to let [InAppChatFragment] handle attachment preview.
                return false
            }

            override fun onExitChatPressed() {
                //Called by default InAppChat's Toolbar back navigation logic to exit chat. You are supposed to hide/remove [InAppChatFragment].
                supportFragmentManager
                    .beginTransaction()
                    .remove(fragment)
                    .commit()
            }
        }

        //3. Set errors handler
        fragment.errorsHandler = object : InAppChatFragment.ErrorsHandler {
            override fun handlerError(error: String) {
                //Your custom handling of general error or use a default handler
                fragment.defaultErrorsHandler.handlerError(error)
            }

            override fun handlerWidgetError(error: String) {
                //Your custom handling of Livechat widget error or use default handler
                fragment.defaultErrorsHandler.handlerWidgetError(error)
            }

            override fun handlerNoInternetConnectionError(hasConnection: Boolean) {
                //Your custom handling of missing network connection error or use default handler
                fragment.defaultErrorsHandler.handlerNoInternetConnectionError(hasConnection)
            }

        }
        
        //4. Add fragment to your activity
        supportFragmentManager
            .beginTransaction()
            .replace(R.id.yourFragmentContainer, fragment, "chatFragmentTag")
            .commit()
    }

}

class InAppChatFragment {

    /**
     * Returns true if chat is loaded and multithread feature is enabled, otherwise returns false.
     */
    val isMultiThread: Boolean

    /**
     * [InAppChatFragment] events listener allows you to listen to chat related events.
     * Your in-app chat events listener set using [InAppChat.setEventsListener] is used as initial default value.
     */
    var eventsListener: InAppChatFragment.EventsListener? = InAppChat.getInstance(context).eventsListener

    /**
     * Allows you to set custom [InAppChatFragment.ErrorsHandler] handler to process chat errors on your own.
     */
    var errorsHandler: InAppChatFragment.ErrorsHandler
    val defaultErrorHandler: InAppChatFragment.ErrorsHandler

    /**
     * Allows you to control presence of InAppChatFragment's Toolbar.
     * If you want to use your own Toolbar, set it to false. Default value is true.
     *
     * When you use own Toolbar it is up to you to handle back navigation logic.
     * You can use [InAppChatFragment.navigateBackOrCloseChat] for default back navigation logic,
     * what handles internal multithread widget navigation together with android native navigation.
     * In case you want to handle back navigation on your own, there is [InAppChatFragment.showThreadList]
     * to navigate from [LivechatWidgetView.THREAD] back to [LivechatWidgetView.THREAD_LIST] in multithread widget.
     */
    var withToolbar: Boolean = true

    /**
     * Allows you to control presence of InAppChatFragment's message input.
     * If you want to use your own message input, set it to false. Default value is true.
     *
     * When you use own message input it is up to you to handle message and attachment sending logic
     * including request Android permissions for attachment picker.
     * You can reuse provided [InAppChatInputView] or create custom UI.
     * Use [InAppChatFragment.sendChatMessage] to send message.
     * Use [InAppChatFragment.sendChatMessageDraft] to send draft message.
     */
    var withInput: Boolean = true

    /**
     * Allows to stop chat connection when fragment is hidden.
     * Chat is reconnected automatically once fragment is shown again.
     * Default value is false.
     *
     * By chat connection you can control push notifications.
     * Push notifications are active only when chat connection is not active.
     *
     * It calls [InAppChatView.stopConnection] when fragment is hidden and [InAppChatView.restartConnection] once fragment is visible again.
     */
    var disconnectChatWhenHidden: Boolean = false

    /**
     * Allows to enable/disable back press handling logic.
     * If true, it triggers default back navigation logic [navigateBackOrCloseChat], useful especially for multithread widgets.
     * If false, back press events are not handled.
     * It does not affect ActionBar back button.
     *
     * Default value is true.
     */
    var handleBackPress: Boolean = true

    /**
     * Set the language of the Livechat Widget.
     *
     * Does nothing if [InAppChatFragment] not attached.
     *
     * @param locale locale's language is used by Livechat Widget and native parts
     */
    @Deprecated("Use setLanguage(LivechatWidgetLanguage) instead")
    fun setLanguage(locale: Locale)

    /**
     * Set InAppChat language
     *
     * Does nothing if [InAppChatFragment] not attached.
     *
     * @param language language is used by Livechat Widget and InAppChat native parts
     */
    fun setLanguage(language: LivechatWidgetLanguage)

    /**
     * Returns current in-app chat language
     *
     * @return current in-app chat language or default LivechatWidgetLanguage.ENGLISH
     */
    fun getLanguage(): LivechatWidgetLanguage

    /**
     * Set contextual data of the Livechat Widget.
     *
     * If the function is called when [InAppChatFragment] is attached and the chat is loaded,
     * data will be sent immediately, otherwise they will be sent to the chat once it is loaded.
     *
     * Every function invocation will overwrite the previous contextual data.
     *
     *
     * @param data                   contextual data in the form of JSON string
     * @param allMultiThreadStrategy multithread strategy flag, true -> ALL, false -> ACTIVE
     * @see [InAppChatFragment.EventsListener.onChatLoaded] to detect if chat is loaded
     */
    @Deprecated(message = "Use sendContextualData(@Nullable String data, @Nullable MultithreadStrategy flag) instead")
    fun sendContextualData(data: String, allMultiThreadStrategy: Boolean)

    /**
     * Set contextual data of the Livechat Widget.
     *
     * If the function is called when [InAppChatFragment] is attached and the chat is loaded,
     * data will be sent immediately, otherwise they will be sent to the chat once it is loaded.
     *
     * Every function invocation will overwrite the previous contextual data.
     *
     * @param data contextual data in the form of JSON string
     * @param flag multithread strategy [MultithreadStrategy]
     * @see [InAppChatFragment.EventsListener.onChatLoaded] to detect if chat is loaded
     */
    fun sendContextualData(data: String, strategy: MultithreadStrategy)
    
    /**
     * Sends draft message to be show in chat to peer's chat.
     *
     * Does nothing if [InAppChatFragment] not attached.
     *
     * @param draft message
     */
    @Deprecated("Use send(payload: MessagePayload) with MessagePayload.Draft() instead")
    fun sendChatMessageDraft(draft: String)

    /**
     * Sends message to the chat with optional [InAppChatMobileAttachment].
     *
     * Does nothing if [InAppChatFragment] not attached.
     *
     * @param message message to be sent, max length allowed is 4096 characters
     * @param attachment to create attachment use [InAppChatMobileAttachment]'s constructor where you provide attachment's mimeType, base64 and filename
     */
    @Deprecated("Use send(payload: MessagePayload) with MessagePayload.Basic() instead")
    fun sendChatMessage(message: String?, attachment: InAppChatMobileAttachment? = null)

    /**
     * Sends a message defined by [payload] data with optional [threadId].
     *
     * You can observe result by [InAppChatFragment.EventsListener.onChatSent] event.
     *
     * @param payload data defining message to be sent
     * @param threadId id of existing thread to send message into, if not provided, it will be sent to the active thread
     */
    fun send(payload: MessagePayload, threadId: String? = null)

    /**
     * Set the theme of the Livechat Widget.
     * You can define widget themes in <a href="https://portal.infobip.com/apps/livechat/widgets">Live Chat widget setup page</a> in Infobip Portal, section `Advanced customization`.
     * Please check widget <a href="https://www.infobip.com/docs/live-chat/widget-customization">documentation</a> for more details.
     *
     * Function allows to change widget theme while chat is shown - in runtime.
     * If you set widget theme before [InAppChatFragment] is shown the theme will be used once chat is loaded.
     *
     * Does nothing if [InAppChatFragment] not attached.
     *
     * @param widgetThemeName unique theme name, empty or blank value is ignored
     */
    fun setWidgetTheme(widgetThemeName: String)

    /**
     * Returns current livechat widget theme.
     *
     * @return applied theme name of livechat widget
     */
    fun getWidgetTheme(): String?

    /**
     * Executes back navigation. In multithread widget it handles internal navigation
     * from [LivechatWidgetView.THREAD] back to [LivechatWidgetView.THREAD_LIST] using
     * [InAppChatFragment.showThreadList], otherwise it triggers [InAppChatFragment.EventsListener.onExitChatPressed] event
     * and [InAppChatFragment.InAppChatActionBarProvider.onInAppChatBackPressed].
     *
     * It is default InAppChatFragment back navigation logic.
     */
    fun navigateBackOrCloseChat()

    /**
     * Creates a new thread with an initial message defined by the given [payload].
     *
     * You can observe the result via the [InAppChatFragment.EventsListener.onChatThreadCreated] event.
     *
     * @param payload The message payload used to start the new thread.
     */
    fun createThread(payload: MessagePayload)

    /**
     * Requests current threads from livechat widget.
     *
     * Does nothing if [InAppChatFragment] not attached.
     *
     * You can observe result by [InAppChatFragment.EventsListener.onChatThreadsReceived] event.
     */
    fun getThreads()

    /**
     * Requests shown thread - active from livechat widget.
     *
     * Does nothing if [InAppChatFragment] not attached.
     *
     * You can observe result by [InAppChatFragment.EventsListener.onChatActiveThreadReceived] event.
     */
    fun getActiveThread()

    /**
     * Navigates livechat widget to thread specified by provided [threadId].
     *
     * Does nothing if [InAppChatFragment] not attached.
     *
     * You can observe result by [InAppChatFragment.EventsListener.onChatThreadShown] event.
     *
     * @param threadId thread to be shown
     */
    fun showThread(threadId: String)

    /**
     * Navigates Livechat widget from [LivechatWidgetView.THREAD] back to [LivechatWidgetView.THREAD_LIST]
     * destination in multithread widget. Does nothing if livechat widget not multithread.
     *
     * Does nothing if [InAppChatFragment] not attached.
     */
    fun showThreadList()
}

class MainActivity: AppCompatActivity() {
  
  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    //1. Injects activity's lifecycle
    val inAppChatView: InAppChatView = findViewById(R.id.inAppChatView)
    inAppChatView.init(lifecycle)

    //2. Sets InAppChatView.EventsListener to handle multithread internal navigation
    inAppChatView.eventsListener = object : InAppChatView.EventsListener {

      override fun onChatLoadingFinished(result: LivechatWidgetResult<Unit>) {
          //Chat has been loaded and connection established.
      }

      override fun onChatConnectionPaused(result: LivechatWidgetResult<Unit>) {
          //Chat connection has been paused.
      }

      override fun onChatConnectionResumed(result: LivechatWidgetResult<Unit>) {
          //Chat connection has been resumed.
      }

      override fun onChatSent(result: LivechatWidgetResult<LivechatWidgetMessage?>) {
          //Called when chat message was sent.
      }

      override fun onChatContextualDataSent(result: LivechatWidgetResult<String?>) {
          //Called when chat contextual data are sent.
      }

      override fun onChatThreadCreated(result: LivechatWidgetResult<LivechatWidgetMessage?>) {
          //Called when chat thread was created.
      }

      override fun onChatThreadsReceived(result: LivechatWidgetResult<LivechatWidgetThreads>) {
          //Called when chat threads were requested.
      }

      override fun onChatActiveThreadReceived(result: LivechatWidgetResult<LivechatWidgetThread?>) {
          //Called when chat active thread was requested.
          //Success result can contains null if there is no existing thread for current user session or current widget destination is not [LivechatWidgetView.THREAD].
      }

      override fun onChatThreadShown(result: LivechatWidgetResult<LivechatWidgetThread>) {
          //Called when chat thread is shown.
      }

      override fun onChatThreadListShown(result: LivechatWidgetResult<Unit>) {
          //Called when chat thread list is shown.
      }

      override fun onChatLanguageChanged(result: LivechatWidgetResult<String?>) {
          //Called when chat language has been changed.
      }

      override fun onChatWidgetThemeChanged(result: LivechatWidgetResult<String?>) {
          //Called when chat theme has been changed.
      }

      override fun onChatControlsVisibilityChanged(isVisible: Boolean) {
          //Chat controls visibility has changed.
      }

      override fun onChatViewChanged(widgetView: LivechatWidgetView) {
          //Chat view has changed.
          //Handles navigation in multithread livechat widget
          when (widgetView) {
              LivechatWidgetView.LOADING,
              LivechatWidgetView.THREAD_LIST,
              LivechatWidgetView.SINGLE_MODE_THREAD -> {
                  //no need to handle internal navigation
              }
              LivechatWidgetView.LOADING_THREAD,
              LivechatWidgetView.THREAD,
              LivechatWidgetView.CLOSED_THREAD -> {
                  //to navigate back to THREAD_LIST, use inAppChatView.showThreadList();
              }
          }
          //Handles message input in multithread livechat widget
          when (widgetView) {
              LivechatWidgetView.LOADING,
              LivechatWidgetView.THREAD_LIST,
              LivechatWidgetView.LOADING_THREAD,
              LivechatWidgetView.CLOSED_THREAD -> {
                  //it is prohibited to send messages
              }
              LivechatWidgetView.SINGLE_MODE_THREAD,
              LivechatWidgetView.THREAD -> {
                  //you can send messages
              }
          }
      }

      override fun onChatWidgetInfoUpdated(widgetInfo: WidgetInfo) {
          //Chat [WidgetInfo] has been updated.
      }

      override fun onChatRawMessageReceived(rawMessage: String) {
          //Chat message has been received.
      }

      override fun onChatAttachmentPreviewOpened(
          url: String?,
          type: String?,
          caption: String?
      ) {
          //Called when attachment from chat has been interacted.
      }
      
    }

    //3. Sets InAppChatView.ErrorsHandler to handle InAppChatView errors on your own
    inAppChatView.errorsHandler = object : InAppChatView.ErrorsHandler {
      override fun handlerError(error: String) {
        //Your custom handling of general error or use a default handler
        inAppChatView.defaultErrorsHandler.handlerError(error);
      }

      override fun handlerWidgetError(error: String) {
        //Your custom handling of Livechat widget error or use default handler
        inAppChatView.defaultErrorsHandler.handlerWidgetError(error);
      }

      override fun handlerNoInternetConnectionError(hasConnection: Boolean) {
        //Your custom handling of missing network connection error or use default handler
        inAppChatView.defaultErrorsHandler.handlerNoInternetConnectionError(hasConnection);
      }

    }
    
  }

}

class InAppChatView {

    /**
     * Returns true if a chat is synchronized and multithread feature is enabled; otherwise returns false
     */
    val isMultiThread: Boolean
    
    /**
     * [InAppChatView] event listener to listen to Livechat widget events.
     */
    var eventsListener: EventsListener?

    /**
     * Sets a custom [InAppChatView.ErrorsHandler] handler to process [InAppChatView] errors on your own.
     */
    var errorsHandler: ErrorsHandler
    val defaultErrorsHandler: ErrorsHandler

    /**
     * Initialize [InAppChatView] with enclosing android component [Lifecycle].
     *
     * Loads chat and establish connection to be able to receive real time updates - new messages.
     * Chat connection is established and stopped based on provided [Lifecycle].
     * Chat connection is active only when [Lifecycle.State] is at least [Lifecycle.State.STARTED].
     *
     * @param lifecycle lifecycle of android Activity or Fragment
     */
    fun init(lifecycle: Lifecycle)

    /**
     * Pauses chat connection.
     *
     * It is not needed to use it in most cases as chat connection is established and paused based on [Lifecycle] provided in [init].
     * Chat connection is paused when [Lifecycle.State] is below [Lifecycle.State.STARTED].
     *
     * By chat connection you can control push notifications.
     * Push notifications are active only when chat connection is not active.
     *
     * Can be used to enable chat's push notifications when [InAppChatView] is not visible.
     * Use [resumeChatConnection] to reestablish chat connection.
     *
     * To detect if chat connection is paused use [EventsListener.onChatConnectionPaused] event from [EventsListener].
     */
    fun pauseChatConnection()

    /**
     * Stops chat connection.
     *
     * It is not needed to use it in most cases as chat connection is established and stopped based on [Lifecycle] provided in [init].
     * Chat connection is stopped when [Lifecycle.State] is below [Lifecycle.State.STARTED].
     *
     * By chat connection you can control push notifications.
     * Push notifications are active only when chat connection is not active.
     *
     * Can be used to enable chat's push notifications when [InAppChatView] is not visible.
     * Use [restartConnection] to reestablish chat connection.
     *
     * To detect if chat connection is stopped use [EventsListener.onChatDisconnected] event from [EventsListener].
     */
    @Deprecated("Use pauseChatConnection() instead")
    fun stopConnection()

    /**
     * Use it to resume chat connection when you previously called [pauseChatConnection].
     *
     * It is not needed to use it in most cases as chat connection is established and stopped based on [Lifecycle] provided in [init].
     * Chat connection is active only when [Lifecycle.State] is at least [Lifecycle.State.STARTED].
     *
     * By chat connection you can control push notifications.
     * Push notifications are suppressed while the chat connection is active.
     *
     * To detect if chat connection was resumed use [EventsListener.onChatConnectionResumed] event from [EventsListener].
     */
    fun resumeChatConnection()

    /**
     * Use it to re-establish chat connection when you previously called [stopConnection].
     *
     * It is not needed to use it in most cases as chat connection is established and stopped based on [Lifecycle] provided in [init].
     * Chat connection is active only when [Lifecycle.State] is at least [Lifecycle.State.STARTED].
     *
     * By chat connection you can control push notifications.
     * Push notifications are suppressed while the chat connection is active.
     *
     * To detect if chat connection was re-established use [EventsListener.onChatReconnected] event from [EventsListener].
     */
    @Deprecated("Use resumeChatConnection() instead")
    fun restartConnection()

    /**
     * Sets the language of a Livechat Widget
     * @param locale locale's language is used by Livechat Widget and native parts
     */
    @Deprecated("Use setLanguage(LivechatWidgetLanguage) instead",)
    fun setLanguage(locale: Locale)

    /**
     * Set InAppChat language
     * @param language language is used by Livechat Widget and InAppChat native parts
     */
    fun setLanguage(language: LivechatWidgetLanguage)

    /**
     * Returns current in-app chat language
     *
     * @return current in-app chat language or default LivechatWidgetLanguage.ENGLISH
     */
    fun getLanguage(): LivechatWidgetLanguage

    /**
     * Set contextual data of the Livechat Widget.
     *
     * If the function is called when the chat is loaded,
     * data will be sent immediately, otherwise they will be sent to the chat once it is loaded.
     *
     * Every function invocation will overwrite the previous contextual data.
     *
     * @param data                   contextual data in the form of JSON string
     * @param allMultiThreadStrategy multithread strategy flag, true -> ALL, false -> ACTIVE
     * @see [InAppChatView.EventsListener.onChatLoaded] to detect if chat is loaded
     */
    @Deprecated("Use sendContextualData(data: String, strategy: MultithreadStrategy) instead")
    fun sendContextualData(data: String, allMultiThreadStrategy: Boolean)

    /**
     * Set contextual data of the Livechat Widget.
     *
     * If the function is called when the chat is loaded,
     * data will be sent immediately, otherwise they will be sent to the chat once it is loaded.
     *
     * Every function invocation will overwrite the previous contextual data.
     *
     * @param data contextual data in the form of JSON string
     * @param flag multithread strategy [MultithreadStrategy]
     * @see [InAppChatView.EventsListener.onChatLoaded] to detect if chat is loaded
     */
    fun sendContextualData(data: String, strategy: MultithreadStrategy)

    /**
     * Sends draft message to be show in chat to peer's chat.
     * @param draft message
     */
    @Deprecated("Use send(payload: MessagePayload) with MessagePayload.Draft() instead")
    fun sendChatMessageDraft(draft: String)

    /**
     * Sends a message to the chat with optional [InAppChatMobileAttachment].
     * @param message message to be sent
     * @param attachment to create an attachment, use [InAppChatMobileAttachment]'s constructor where you provide attachment's mimeType, base64, and filename
     */
    @Deprecated("Use send(payload: MessagePayload) with MessagePayload.Basic() instead")
    fun sendChatMessage(message: String?, attachment: InAppChatMobileAttachment? = null)

    /**
     * Sends a message defined by the given [payload] to the specified [threadId], if provided.
     * Otherwise, the message will be sent to the currently active thread.
     *
     * You can observe the result via the [InAppChatView.EventsListener.onChatSent] event.
     *
     * @param payload The message payload to send.
     * @param threadId The ID of the existing thread to send the message to. If `null`, the active thread will be used.
     */
    fun send(payload: MessagePayload, threadId: String? = null)

    /**
     * Set the theme of the Livechat Widget.
     * You can define widget themes in <a href="https://portal.infobip.com/apps/livechat/widgets">Live Chat widget setup page</a> in Infobip Portal, section `Advanced customization`.
     * Please check widget <a href="https://www.infobip.com/docs/live-chat/widget-customization">documentation</a> for more details.
     *
     * Function allows to change widget theme while chat is shown - in runtime.
     * If you set widget theme before chat is initialized by [InAppChatView.init] the theme will be used once chat is loaded.
     *
     * @param widgetThemeName unique theme name, empty or blank value is ignored
     */
    fun setWidgetTheme(widgetThemeName: String)

    /**
     * Get current livechat widget theme.
     *
     * @return applied theme name of livechat widget
     */
    fun getWidgetTheme(): String?

    /**
     * Creates a new thread with an initial message defined by the given [payload].
     *
     * You can observe the result via the [InAppChatView.EventsListener.onChatThreadCreated] event.
     *
     * @param payload The message payload used to start the new thread.
     */
    fun createThread(payload: MessagePayload)

    /**
     * Requests current threads from livechat widget.
     *
     * You can observe result by [InAppChatView.EventsListener.onChatThreadsReceived] event.
     */
    fun getThreads()

    /**
     * Requests shown thread - active from livechat widget.
     *
     * You can observe result by [InAppChatView.EventsListener.onChatActiveThreadReceived] event.
     */
    fun getActiveThread()

    /**
     * Navigates livechat widget to thread specified by provided [threadId].
     *
     * You can observe result by [InAppChatView.EventsListener.onChatThreadShown] event.
     *
     * @param threadId thread to be shown
     */
    fun showThread(threadId: String)

    /**
     * Navigates livechat widget from [LivechatWidgetView.THREAD] back to [LivechatWidgetView.THREAD_LIST] destination in multithread widget. It does nothing if widget is not multithread.
     */
    fun showThreadList()
}

InAppChat.getInstance(context).setTheme(
    InAppChatTheme(
        InAppChatToolbarStyle(), //chat toolbar
        InAppChatToolbarStyle(), //attachment toolbar
        InAppChatStyle(),
        InAppChatInputViewStyle()
    )
)

InAppChat.getInstance(context).setWidgetTheme("myThemeName")

val tapReceiver = object: BroadcastReceiver() {
    override fun onReceive(context:Context, intent: Intent) {
        val message = Message.createFrom(intent)
        val action = OpenLivechatAction.parseFrom(message)
        if (message.isChatMessage()) {
            // in-app chat message push notification tapped
        } else if (action != null) {
            // notification action "Open chatbot in LiveChat" triggered
        }
    }
}
LocalBroadcastManager.getInstance(context).registerReceiver(tapReceiver, IntentFilter(Event.NOTIFICATION_TAPPED.key))

val notificationInteractionHandler = object: InAppChatNotificationInteractionHandler() {
    override fun onNotificationInteracted(message: Message) {
        val action = OpenLivechatAction.parseFrom(message)
        if (message.isChatMessage()) {
            // in-app chat message push notification tapped
        } else if (action != null) {
            // notification action "Open chatbot in LiveChat" triggered
        }
    }
}
InAppChat.getInstance(context).setNotificationInteractionHandler(notificationInteractionHandler)

val currentHandler = InAppChat.getInstance(context).getNotificationInteractionHandler()
val defaultHandler = InAppChat.getInstance(context).getDefaultNotificationInteractionHandler()
InAppChat.getInstance(context).setNotificationInteractionHandler(defaultHandler)

InAppChat.getInstance(context).setChatPushTitle("Custom chat push title")
InAppChat.getInstance(context).setChatPushBody("Custom chat push body")

val messageCounter = InAppChat.getInstance(context).messageCounter
// use the count the way that suits you

InAppChat.getInstance(context).resetMessageCounter()

override fun onReceive(context: Context?, intent: Intent) {
    val unreadChatMessagesCounter = intent.getIntExtra(BroadcastParameter.EXTRA_UNREAD_CHAT_MESSAGES_COUNT)
}

private val eventReceiver = object: BroadcastReceiver() {
    override fun onReceive(context:Context, intent: Intent) {
        // process event occurrence
    }
}
LocalBroadcastManager.getInstance(context).registerReceiver(eventReceiver, IntentFilter(InAppChatEvent.CHAT_CONFIGURATION_SYNCED.key))

override fun onReceive(context: Context, intent: Intent) {
    val unreadMessagesCount = intent.getIntExtra(BroadcastParameter.EXTRA_UNREAD_CHAT_MESSAGES_COUNT)
}

override fun onReceive(context: Context, intent: Intent) {
    val view = intent.getStringExtra(BroadcastParameter.EXTRA_CHAT_VIEW)
    val livechatWidgetView = LivechatWidgetView.valueOf(view)
}

override fun onReceive(context: Context, intent: Intent) {
    val livechatRegistrationId = intent.getStringExtra(BroadcastParameter.EXTRA_LIVECHAT_REGISTRATION_ID)
}

override fun onReceive(context: Context, intent: Intent) {
    val isChatAvailable = intent.getStringExtra(BroadcastParameter.EXTRA_IS_CHAT_AVAILABLE)
}

InAppChat.getInstance(context).setLanguage(LivechatWidgetLanguage.SPANISH)

class MainActivity: AppCompatActivity(), InAppChatFragment.InAppChatActionBarProvider {

  override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    //Shows in-app chat as Fragment
    InAppChat.getInstance(applicationContext).showInAppChatFragment(supportFragmentManager, R.id.fragmentContainer)
  }

  override fun getOriginalSupportActionBar(): ActionBar? = supportActionBar

  override fun onInAppChatBackPressed() {
    InAppChat.getInstance(this).hideInAppChatFragment(supportFragmentManager)
    //you can pass "true" as second argument to disconnect chat when fragment is hidden to receive push notifications
    //InAppChat.getInstance(this).hideInAppChatFragment(supportFragmentManager, true)
  }
  
}

/*
1 - A user authenticates in your system and you recognize their unique identifier.
2 - You call the `personalize()` function, pass in the unique identifier, and optionally, other attributes, such as first name, second name, etc.
3 - You can now display a chat as authenticated by doing the following:
*/

InAppChat.getInstance(context).widgetJwtProvider = JwtProvider {
    //every invocation creates and returns a fresh token
    "your JWT"
}
InAppChat.getInstance(context).inAppChatScreen().show()

val api: LivechatWidgetApi = InAppChat.getInstance(context).livechatWidgetApi

/**
 * The `LivechatWidgetApi` interface provides methods to interact with the Livechat widget.
 * It allows you to perform various actions such as sending messages, setting themes, and managing the widget's state.
 * It creates queue for widget functions execution using Kotlin Mutex, single function is executed at a time.
 *
 * ### Using `LivechatWidgetEventsListener`
 * To get the real return value from the Livechat widget, you should use the [LivechatWidgetEventsListener].
 * This listener provides events that you can handle to get the actual data from the widget.
 *
 */
interface LivechatWidgetApi {
    
    /**
     * Indicates if livechat widget is loaded.
     */
    val isWidgetLoaded: Boolean

    /**
     * Listener for livechat widget events. It allows to observe widget loading state, widget events and widget functions results.
     */
    var eventsListener: LivechatWidgetEventsListener?

    /**
     * [JwtProvider] gives livechat widget ability to authenticate.
     * Must be set before calling [loadWidget] method. If not set, it will be taken from current `InAppChat` configuration.
     */
    var jwtProvider: JwtProvider?

    /**
     * Livechat widget domain.
     * Must be set before calling [loadWidget] method. If not set, it will be taken from current `InAppChat` configuration.
     */
    var domain: String?

    /**
     * Timeout duration for loading the Livechat widget, in milliseconds.
     *
     * This value must be set **before** calling [loadWidget].
     *
     * - **Minimum allowed:** 5,000 ms (5 seconds)
     * - **Maximum allowed:** 300,000 ms (5 minutes)
     * - **Default value:** 10,000 ms (10 seconds)
     *
     * @throws IllegalStateException if the value is set outside the allowed range.
     */
    @set:Throws(IllegalStateException::class)
    var loadingTimeoutMillis: Long

    /**
     * Triggers livechat widget loading. Does nothing, if widget is already loaded.
     * You can observe loading's result by [LivechatWidgetEventsListener.onLoadingFinished] event.
     * If you want to force load widget again, you need to call [reset] first.
     * If you want to load widget with current `InAppChat` configuration, you can call [loadWidget] without parameters.
     * You can control widget loading timeout by setting [loadingTimeoutMillis] property.
     *
     * @param widgetId livechat widget id to be loaded, if not provided, it will be taken from current configuration
     * @param jwt jwt token for authentication, if not provided, it will be taken from current `InAppChat` configuration
     * @param domain domain for livechat widget, if not provided, it will be taken from current `InAppChat` configuration
     * @param theme theme for livechat widget, if not provided, it will be taken from current `InAppChat` configuration
     * @param language language for livechat widget, if not provided, it will be taken from current `InAppChat` configuration
     */
    fun loadWidget(
        widgetId: String? = null,
        jwt: String? = null,
        domain: String? = null,
        theme: String? = null,
        language: LivechatWidgetLanguage? = null,
    )

    /**
     * Triggers livechat widget loading with current `InAppChat` configuration. Does nothing, if widget is already loaded.
     * You can observe loading's result by [LivechatWidgetEventsListener.onLoadingFinished] event.
     * If you want to force load widget again, you need to call [reset] first.
     * You can control widget loading timeout by setting [loadingTimeoutMillis] property.
     *
     * @param widgetId livechat widget id to be loaded, if not provided, it will be taken from current configuration
     */
    fun loadWidget(
        widgetId: String? = null,
    ) = loadWidget(widgetId, jwt = null, domain = null, theme = null, language = null)

    /**
     * Triggers livechat widget loading with current `InAppChat` configuration. Does nothing, if widget is already loaded.
     * You can observe loading's result by [LivechatWidgetEventsListener.onLoadingFinished] event.
     * If you want to force load widget again, you need to call [reset] first.
     * You can control widget loading timeout by setting [loadingTimeoutMillis] property.
     */
    fun loadWidget() = loadWidget(widgetId = null, jwt = null, domain = null, theme = null, language = null)

    /**
     * Pauses livechat widget connection, but widget stay loaded in WebView.
     * Widget connection and loaded state are independent.
     *
     * By the connection you can control push notifications.
     * Push notifications are active only when the connection is not active.
     *
     * Use [resumeConnection] to reestablish connection.
     *
     * To detect if the connection is paused use [LivechatWidgetEventsListener.onConnectionPaused] event.
     */
    fun pauseConnection()

    /**
     * Resumes livechat widget connection when you previously called [pauseConnection].
     *
     * By the connection you can control push notifications.
     * Push notifications are active only when the connection is not active.
     *
     * Use [pauseConnection] to pause connection.
     *
     * To detect if the connection is resumed use [LivechatWidgetEventsListener.onConnectionResumed] event.
     */
    fun resumeConnection()

    /**
     * Sends a message defined by the given [payload] to the specified [threadId], if provided.
     * Otherwise, the message will be sent to the currently active thread.
     *
     * You can observe the result via the [LivechatWidgetEventsListener.onSent] event.
     *
     * @param payload The message payload to send.
     * @param threadId The ID of the existing thread to send the message to. If `null`, the active thread will be used.
     */
    fun send(payload: MessagePayload, threadId: String? = null)
  
    /**
     * Sends a message defined by the given [payload] to the currently active thread.
     *
     * You can observe the result via the [LivechatWidgetEventsListener.onSent] event.
     *
     * @param payload The message payload to send.
     */
    fun send(payload: MessagePayload) = send(payload = payload, threadId = null)

    /**
     * Sends contextual data.
     *
     * You can observe result by [LivechatWidgetEventsListener.onContextualDataSent] event.
     *
     * @param data contextual data in JSON format
     * @param multiThreadFlag multithread strategy flag
     */
    fun sendContextualData(data: String, multiThreadFlag: MultithreadStrategy)

    /**
     * Creates a new thread with an initial message defined by the given [payload].
     *
     * You can observe the result via the [LivechatWidgetEventsListener.onThreadCreated] event.
     *
     * @param payload The message payload used to start the new thread.
     */
    fun createThread(payload: MessagePayload)

    /**
     * Requests current threads from livechat widget.
     *
     * You can observe result by [LivechatWidgetEventsListener.onThreadsReceived] event.
     */
    fun getThreads()

    /**
     * Requests shown thread - active from livechat widget.
     *
     * You can observe result by [LivechatWidgetEventsListener.onActiveThreadReceived] event.
     */
    fun getActiveThread()

    /**
     * Navigates livechat widget to thread specified by provided [threadId].
     *
     * You can observe result by [LivechatWidgetEventsListener.onThreadShown] event.
     *
     * @param threadId thread to be shown
     */
    fun showThread(threadId: String)

    /**
     * Navigates livechat widget from [LivechatWidgetView.THREAD] back to [LivechatWidgetView.THREAD_LIST] destination in multithread widget. It does nothing if widget is not multithread.
     *
     * You can observe result by [LivechatWidgetEventsListener.onThreadListShown] or [LivechatWidgetEventsListener.onWidgetViewChanged] event.
     */
    fun showThreadList()

    /**
     * Sets a livechat widget's language.
     *
     * You can observe result by [LivechatWidgetEventsListener.onLanguageChanged] event.
     *
     * @param language language to be set
     */
    fun setLanguage(language: LivechatWidgetLanguage)

    /**
     * Sets a livechat widget's theme.
     *
     * You can observe result by [LivechatWidgetEventsListener.onThemeChanged] event.
     *
     * You can define widget themes in <a href="https://portal.infobip.com/apps/livechat/widgets">Live Chat widget setup page</a> in Infobip Portal, section `Advanced customization`.
     * Please check widget <a href="https://www.infobip.com/docs/live-chat/widget-customization">documentation</a> for more details.
     *
     * @param themeName theme name to be set
     */
    fun setTheme(themeName: String)

    /**
     * Resets livechat widget state and loads blank page.
     */
    fun reset()

}

/**
 * Interface for listening to events from livechat widget.
 *
 * You can use [DefaultLivechatWidgetEventsListener] to override only necessary methods.
 */
interface LivechatWidgetEventsListener {

    /**
     * Called when livechat widget page starts loading.
     */
    fun onPageStarted(url: String?)

    /**
     * Called when livechat widget page loading finished.
     */
    fun onPageFinished(url: String?)

    /**
     * Called when the livechat widget has finished loading.
     * A success result indicates that the loading process is complete.
     * The boolean flag in the payload specifies whether the widget is fully loaded and ready for use.
     * Typically, this flag will be true. However, there are scenarios where the loading completes successfully, but the widget is not loaded,
     * such as when [LivechatWidgetApi.reset] is called.
     */
    fun onLoadingFinished(result: LivechatWidgetResult<Boolean>)

    /**
     * Called when livechat widget connection is paused.
     */
    fun onConnectionPaused(result: LivechatWidgetResult<Unit>)

    /**
     * Called when livechat widget connection is resumed.
     */
    fun onConnectionResumed(result: LivechatWidgetResult<Unit>)

    /**
     * Called when any message payload is sent.
     */
    fun onSent(result: LivechatWidgetResult<LivechatWidgetMessage?>)

    /**
     * Called when contextual data is sent.
     */
    fun onContextualDataSent(result: LivechatWidgetResult<String?>)

    /**
     * Called when livechat widget threads were requested.
     */
    fun onThreadsReceived(result: LivechatWidgetResult<LivechatWidgetThreads>)

    /**
     * Called when livechat widget active thread was requested.
     * Success result can contain null if there is no existing thread for current user session or current widget destination is not [LivechatWidgetView.THREAD].
     */
    fun onActiveThreadReceived(result: LivechatWidgetResult<LivechatWidgetThread?>)

    /**
     * Called when livechat widget thread was created.
     */
    fun onThreadCreated(result: LivechatWidgetResult<LivechatWidgetMessage?>)

    /**
     * Called when livechat widget thread is shown.
     */
    fun onThreadShown(result: LivechatWidgetResult<LivechatWidgetThread>)

    /**
     * Called when livechat widget thread list is shown.
     */
    fun onThreadListShown(result: LivechatWidgetResult<Unit>)

    /**
     * Called when livechat widget language is changed.
     */
    fun onLanguageChanged(result: LivechatWidgetResult<String?>)

    /**
     * Called when livechat widget theme is changed.
     */
    fun onThemeChanged(result: LivechatWidgetResult<String?>)

    /**
     * Called when livechat widget controls visibility changes.
     * It says when you can show or hide input field.
     */
    fun onControlsVisibilityChanged(visible: Boolean)

    /**
     * Called when livechat widget attachment preview is interacted.
     */
    fun onAttachmentPreviewOpened(url: String?, type: String?, caption: String?)

    /**
     * Called when livechat widget view changes.
     */
    fun onWidgetViewChanged(view: LivechatWidgetView)

    /**
     * Called when raw message is received from livechat widget.
     */
    fun onRawMessageReceived(message: String?)
}

/**
 * Base class for all message payload types of livechat widget.
 *
 * Each subclass represents a specific kind of message that can be sent, such as text, draft, attachment, or custom data.
 *
 * @property type The type identifier of the message, used to distinguish payload variants.
 */
sealed class MessagePayload(
    val type: LivechatWidgetMessageType
) {

    /**
     * Represents a draft message.
     *
     * @property message The text content of the draft. Must be non-blank and no longer than
     * [LivechatWidgetApi.MESSAGE_MAX_LENGTH] characters.
     *
     * @throws IllegalArgumentException If [message] is blank or exceeds the maximum allowed length.
     */
    data class Draft @Throws(IllegalArgumentException::class) constructor(
        val message: String
    ) : MessagePayload(LivechatWidgetMessageType.DRAFT) 

    /**
     * Represents a basic text message, optionally containing an attachment.
     *
     * Either [message] or [attachment] must be provided.
     *
     * @property message The text content of the message. Must be non-blank and no longer than
     * [LivechatWidgetApi.MESSAGE_MAX_LENGTH] characters, if present.
     * @property attachment An optional attachment associated with the message. Must be valid if provided.
     *
     * @throws IllegalArgumentException If both [message] and [attachment] are null,
     * if [message] is blank or too long, or if [attachment] is invalid.
     */
    data class Basic @Throws(IllegalArgumentException::class) @JvmOverloads constructor(
        val message: String?,
        override val attachment: InAppChatMobileAttachment? = null,
    ) : MessagePayload(LivechatWidgetMessageType.BASIC)

    /**
     * Represents a message containing structured custom data related to the conversation.
     *
     * This type of message can optionally include contextual text from the agent and/or the user.
     *
     * @property customData A JSON string representing the custom data payload. Must be a valid JSON object.
     * @property agentMessage An optional message visible only to the agent providing context for the custom data.
     * @property userMessage An optional message visible only to the user and agent related to the custom data.
     */
    data class CustomData @JvmOverloads constructor(
        val customData: String,
        val agentMessage: String? = null,
        val userMessage: String? = null
    ) : MessagePayload(LivechatWidgetMessageType.CUSTOM_DATA)

}