ariane/app/src/main/java/oppen/tva/ui/TvaActivity.kt

package oppen.tva.ui

import android.content.ClipData
import android.content.ClipboardManager
import android.content.Context
import android.content.Intent
import android.net.Uri
import android.os.Bundle
import android.view.inputmethod.EditorInfo
import androidx.activity.viewModels
import androidx.appcompat.app.AlertDialog
import androidx.appcompat.app.AppCompatActivity
import androidx.databinding.DataBindingUtil
import androidx.recyclerview.widget.LinearLayoutManager
import com.google.android.material.snackbar.Snackbar
import oppen.tva.R
import oppen.tva.databinding.ActivityTvaBinding
import oppen.tva.io.GeminiResponse
import oppen.tva.io.TvaState
import oppen.tva.io.history.CacheInterface
import oppen.tva.ui.overflow.OverflowPopup
import oppen.tva.ui.set_home.SetHome
import oppen.tva.ui.tabs.NewTabPopup
import oppen.tva.ui.tabs.TabsDialog
import oppen.visibleRetainingSpace


class TvaActivity : AppCompatActivity() {

    private val model by viewModels<TvaViewModel>()
    private lateinit var binding: ActivityTvaBinding
    private val adapter = GemtextAdapter { uri, longTap, view ->
        if(longTap){
            NewTabPopup.show(view){ menuId ->
                when (menuId) {
                    R.id.link_menu_open_in_new_tab -> {
                        model.newTab(uri)
                    }
                }
            }
        }else{
            model.request(uri)
        }

    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = DataBindingUtil.setContentView(this, R.layout.activity_tva)
        binding.viewmodel = model
        binding.lifecycleOwner = this

        binding.gemtextRecycler.layoutManager = LinearLayoutManager(this)
        binding.gemtextRecycler.adapter = adapter

        model.initialise(CacheInterface.default(this)){ state ->
            when(state){
                is TvaState.AppQuery -> runOnUiThread{ showAlert("App backdoor/query not implemented yet") }
                is TvaState.Requesting -> loadingView(true)
                is TvaState.NotGeminiRequest -> externalProtocol(state)
                is TvaState.ResponseError -> showAlert("${GeminiResponse.getCodeString(state.header.code)}: ${state.header.meta}")
                is TvaState.ResponseGemtext -> renderGemtext(state)
                is TvaState.ResponseText -> runOnUiThread{ showAlert("Plain text display not implemented") }
                is TvaState.TabChange -> binding.tabCount.text = "${state.count}"
                is TvaState.Blank -> {
                    binding.addressEdit.setText("")
                    adapter.render(arrayListOf())
                }
            }
        }

        binding.addressEdit.setOnEditorActionListener { _, actionId, _ ->
            when (actionId) {
                EditorInfo.IME_ACTION_GO -> {
                    model.request(binding.addressEdit.text.toString())
                    return@setOnEditorActionListener true
                }
                else -> return@setOnEditorActionListener false
            }
        }

        binding.more.setOnClickListener {
            OverflowPopup.show(binding.more){menuId ->
                when (menuId) {
                    R.id.overflow_menu_share -> {
                        Intent().apply {
                            action = Intent.ACTION_SEND
                            putExtra(Intent.EXTRA_TEXT, binding.addressEdit.text.toString())
                            type = "text/plain"
                            startActivity(Intent.createChooser(this, null))
                        }
                    }
                    R.id.overflow_menu_about -> {

                    }
                    R.id.overflow_menu_set_home -> {
                        SetHome.show(this, binding.addressEdit.text.toString()){
                            showAlert("Home capsule updated")
                        }
                    }
                    R.id.overflow_menu_copy -> {
                        val clipboard = getSystemService(CLIPBOARD_SERVICE) as ClipboardManager
                        val clip = ClipData.newPlainText(getString(R.string.gemini_address), binding.addressEdit.text.toString())
                        clipboard.setPrimaryClip(clip)
                        Snackbar.make(binding.root, getString(R.string.address_copied_to_clipboard), Snackbar.LENGTH_SHORT).setAction(R.string.share) {
                            Intent().apply {
                                action = Intent.ACTION_SEND
                                putExtra(Intent.EXTRA_TEXT, binding.addressEdit.text.toString())
                                type = "text/plain"
                                startActivity(Intent.createChooser(this, null))
                            }
                        }.show()
                    }
                }
            }
        }
        binding.home.setOnClickListener {
            val prefs = getSharedPreferences("oppen.tva.ui.set_home", Context.MODE_PRIVATE)
            val home = prefs.getString("home", "gemini://gemini.circumlunar.space/")
            model.request(home!!)
        }
        binding.tabs.setOnClickListener {
            TabsDialog().show(this, model)
        }
    }

    private fun showAlert(message: String) = runOnUiThread{
        loadingView(false)

        if(message.length > 40){
            AlertDialog.Builder(this)
                .setMessage(message)
                .show()
        }else {
            Snackbar.make(binding.root, message, Snackbar.LENGTH_SHORT).show()
        }
    }

    private fun externalProtocol(state: TvaState.NotGeminiRequest) = runOnUiThread {
        loadingView(false)
        val browserIntent = Intent(Intent.ACTION_VIEW, Uri.parse(state.uri.toString()))
        startActivity(browserIntent)
    }

    private fun renderGemtext(state: TvaState.ResponseGemtext) = runOnUiThread {
        loadingView(false)
        binding.addressEdit.setText(state.uri.toString())
        adapter.render(state.lines)
    }

    private fun loadingView(visible: Boolean) = runOnUiThread {
        binding.progressBar.visibleRetainingSpace(visible)
        if(visible) binding.appBar.setExpanded(true)
    }

    @ExperimentalStdlibApi
    override fun onBackPressed() {
        if(model.canGoBack()){
            model.goBack()
        }else{
            super.onBackPressed()
        }
    }

    override fun onDestroy() {
        super.onDestroy()
        model.persistTabState()
    }
}