ChatSingleActivity

package com.meetandright.ui.homescreen.fragments.chats.chatSingle

import android.app.AlertDialog
import android.content.*
import android.os.Bundle
import android.os.Handler
import android.os.IBinder
import android.view.inputmethod.EditorInfo
import android.widget.TextView
import androidx.localbroadcastmanager.content.LocalBroadcastManager
import androidx.recyclerview.widget.LinearLayoutManager
import com.meetandright.R
import com.meetandright.data.entity.Message
import com.meetandright.data.preference.Preference
import com.meetandright.data.preference.PreferenceManager
import com.meetandright.events.RxEventBus
import com.meetandright.ui.base.BaseContract
import com.meetandright.ui.base.inject.BaseInjectActivity
import com.meetandright.ui.homescreen.fragments.chats.chatSingle.entity.MessageObject
import com.meetandright.ui.homescreen.fragments.discover.viewProfile.ViewProfileActivity
import com.meetandright.ui.profile.UserProfileMetadata
import com.meetandright.utils.extensions.*
import com.meetandright.utils.rx.RxViewsClick
import io.reactivex.rxkotlin.addTo
import kotlinx.android.synthetic.main.activity_chat_single.*
import kotlinx.android.synthetic.main.app_toolbar_chat_single.*
import timber.log.Timber
import javax.inject.Inject

class ChatSingleActivity : BaseInjectActivity(), ChatSingleContract.View, ServiceConnection {

    @Inject lateinit var presenter: ChatSinglePresenter
    override fun getPresenter(): BaseContract.Presenter<*>? = presenter
    @Inject lateinit var rxEventBus: RxEventBus

    private var socketService: SocketService? = null

    private var adapter: ChatSingleAdapter? = null

    private var chatId = ""
    private var userId = ""
    private var userPhotos = arrayListOf<String>()
    private var firstName = ""
    private var dateOfBirth = ""
    private var metroArea = ""
    private var education = ""
    private var profession = ""
    private var description = ""

    override fun onCreate(savedInstanceState: Bundle?) {
        presentationComponent.inject(this)
        presenter.attachToView(this)
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_chat_single)

        chatId = intent.getStringExtra("chatId") ?: ""
        userId = intent.getStringExtra("userId") ?: ""
        userPhotos = intent.getStringArrayListExtra("userPhotos") ?: arrayListOf()
        firstName = intent.getStringExtra("firstName") ?: ""
        dateOfBirth = intent.getStringExtra("dateOfBirth") ?: ""
        metroArea = intent.getStringExtra("metroArea") ?: ""
        education = intent.getStringExtra("education") ?: ""
        profession = intent.getStringExtra("profession") ?: ""
        description = intent.getStringExtra("description") ?: ""

        Timber.e("firstName = $firstName")
        if (firstName.isEmpty()) {
            presenter.getChat(chatId)
        }

        initListeners()
        setupToolbar()
        setupList()
    }

    private fun initListeners() {
        btnSendMessage.setOnClickListener {
            if (etWriteMessage.text.toString().trim().isNotEmpty()) {
                if (checkInternetConnection()) {
                    Timber.e("Send message, userId = $userId, ${UserProfileMetadata.user?.id}, socketService = $socketService")
                    socketService?.sendMessage(UserProfileMetadata.user?.id ?: "", etWriteMessage.text.toString().trim(), chatId)
                    etWriteMessage.setText("")
                }
            }
        }
        etWriteMessage.setOnEditorActionListener(TextView.OnEditorActionListener { view, keyCode, event ->
            if (keyCode == EditorInfo.IME_ACTION_DONE) {
                btnSendMessage.performClick()
                return@OnEditorActionListener true
            }
            false
        })
        etWriteMessage.setOnClickListener {
            Handler().postDelayed({
                chatList?.scrollToPosition(presenter.chat2.size-1)
            }, 200)
        }
        etWriteMessage.setOnFocusChangeListener { view, b ->
            if (b) {
                Handler().postDelayed({
                    chatList?.scrollToPosition(presenter.chat2.size-1)
                }, 200)
            }
        }
        RxViewsClick.create(ivOpponentAvatar, layoutToolbarOpponent)
            .subscribe({
                viewProfile()
            }, {
                Timber.e("Error = ${it.message}")
            })
            .addTo(getDestroyDisposable())
    }

    private fun setupToolbar() {
        btnChatSingleBack.setOnClickListener { finish() }
        btnMenuSettings.setOnClickListener { openMenu() }
        if (firstName.isNotEmpty()) {
            tvNameAndAge.text = firstName.plus(", ").plus(getAge(dateOfBirth))
            tvMetroArea.text = metroArea
            ivOpponentAvatar.load(this, getImageLinkMedium(userPhotos.first()), callback = { ivOpponentAvatar.show() }, failed = { })
        }
    }

    private fun openMenu() {
        val actions = resources.getStringArray(R.array.chat_single_menu)
        val dialog = AlertDialog.Builder(this)
            .setItems(actions) { dialogInterface, selectedIndex ->
                when (selectedIndex) {
                    0 -> reportUser()
                    1 -> unmatch()
                    2 -> viewProfile()
                }
                dialogInterface.dismiss()
            }
            .create()
        dialog.show()
    }

    private fun reportUser() {
        if (checkInternetConnection()) {
            showReportDialog(getActivityContext()) { reportMsg ->
                presenter.report(userId, reportMsg)
            }
        }
    }

    private fun unmatch() {
        if (checkInternetConnection()) {
            showUnmatchDialog(getActivityContext()) {
                presenter.unmatchUser(userId)
            }
        }
    }

    private fun viewProfile() {
        ViewProfileActivity.startActivity(this, userPhotos, firstName, dateOfBirth, metroArea, education, profession, description)
    }

    private fun setupList() {
        chatList?.let { it.layoutManager = LinearLayoutManager(getActivityContext()) }
        val photo = if (userPhotos.isNotEmpty()) userPhotos.first() else ""
        adapter = ChatSingleAdapter(presenter.chat2, photo)
        chatList.adapter = adapter
        adapter?.notifyDataSetChanged()
    }

    override fun onChatLoaded() {
        firstName = presenter.user?.firstName ?: ""
        dateOfBirth = presenter.user?.dateOfBirth ?: ""
        metroArea = presenter.user?.metroArea ?: ""
        userPhotos = presenter.user?.photos ?: arrayListOf()
        setupToolbar()
        adapter?.notifyDataSetChanged()
        chatList.post {
            chatList.scrollToPosition(presenter.chat2.size-1)
        }
        Timber.e("onChatLoaded, socketService = $socketService")
        socketService?.enterChat(chatId)
    }

    override fun onReport() {
        finish()
    }

    override fun onUnmatch() {
        finish()
    }

    private var m_serviceBound = false

    override fun onDestroy() {
        Timber.e("onDestroy, socketService = $socketService")
        super.onDestroy()
    }

    @Inject lateinit var prefs: PreferenceManager

    override fun onResume() {
        super.onResume()

//        SocketService.prefs = prefs
//        val intent1 = Intent(this@ChatSingleActivity, SocketService::class.java)
//        intent1.putExtra("token", prefs.getObject(Preference.KEY_MR_ACCESS_TOKEN, String::class.java))
//        startService(intent1)

        LocalBroadcastManager.getInstance(this).registerReceiver(mMessageReceiver, IntentFilter("ChatSocket"))
        applicationContext.bindService(Intent(this, SocketService::class.java), this, 0)
        m_serviceBound = true
        Timber.e("onResume, socketService = $socketService")

        presenter.getChat(chatId)
    }

    override fun onPause() {
        socketService?.leaveChat(chatId)
        super.onPause()
        LocalBroadcastManager.getInstance(this).unregisterReceiver(mMessageReceiver)
        Timber.e("onPause, m_serviceBound = $m_serviceBound, socketService = $socketService")
        if (m_serviceBound) {
            applicationContext.unbindService(this);
            m_serviceBound = false;
        }
    }

    private val mMessageReceiver = object : BroadcastReceiver() {
        override fun onReceive(context: Context?, intent: Intent?) {

            if (intent?.hasExtra("newMessage") == true) {
                val newMessage = intent.getStringExtra("newMessage")
                val messageId = intent.getStringExtra("messageId")
                val createdAt = intent.getStringExtra("createdAt")
                val authorId = intent.getStringExtra("authorId")
                Timber.e("newMessage = $newMessage, createdAt = $createdAt, text = $newMessage, messageId = $messageId")

                presenter.chat2.add(MessageObject("MESSAGE", Message(messageId, newMessage, authorId, createdAt)))
                adapter?.notifyItemInserted(presenter.chat2.size-1)
                chatList.scrollToPosition(presenter.chat2.size-1)
            }
        }
    }

    override fun onServiceConnected(p0: ComponentName?, binder: IBinder?) {
        socketService = (binder as SocketService.MyBinder).service
        Timber.e("onServiceConnected, socketService = $socketService, chatId = $chatId")
        socketService?.enterChat(chatId)
    }

    override fun onServiceDisconnected(p0: ComponentName?) {
        socketService = null
        Timber.e("onServiceDisconnected, socketService = $socketService")
    }

}