package com.foodient.whisk.features.main

import android.content.ClipboardManager
import android.os.Bundle
import android.view.View
import android.view.ViewGroup
import androidx.coordinatorlayout.widget.CoordinatorLayout
import androidx.core.content.getSystemService
import androidx.core.text.buildSpannedString
import androidx.core.view.forEach
import androidx.lifecycle.Lifecycle
import com.foodient.whisk.BuildConfig
import com.foodient.whisk.R
import com.foodient.whisk.core.extension.color
import com.foodient.whisk.core.extension.gone
import com.foodient.whisk.core.extension.injectPresenter
import com.foodient.whisk.core.extension.installModule
import com.foodient.whisk.core.extension.postSelf
import com.foodient.whisk.core.extension.visible
import com.foodient.whisk.core.notification.NotificationHelper
import com.foodient.whisk.core.notification.SystemMessage
import com.foodient.whisk.core.notification.SystemMessage.Notification.Duration
import com.foodient.whisk.core.ui.fragment.BaseFragment
import com.foodient.whisk.data.user.UserInfoProvider
import com.foodient.whisk.data.user.UserInfoProviderImpl
import com.foodient.whisk.features.main.nativeshare.notarecipe.NotARecipeBottomSheetDialogFragment
import com.foodient.whisk.navigation.main.MainFlowScreens
import com.wootric.androidsdk.Wootric
import kotlinx.android.synthetic.main.fragment_main.*
import ru.terrakok.cicerone.android.support.SupportAppScreen
import toothpick.Scope
import toothpick.ktp.binding.bind

class MainFlowFragment : BaseFragment(), MainFlowView {
    override val layoutRes = R.layout.fragment_main

    private val currentTabFragment: BaseFragment?
        get() = childFragmentManager.fragments.firstOrNull { !it.isHidden } as? BaseFragment

    private val presenter: MainFlowPresenter by injectPresenter()

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        configureBottomTabs()
        selectTab(
            when (currentTabFragment?.tag) {
                shoppingListTab.screenKey -> shoppingListTab
                recipesListTab.screenKey -> recipesListTab
                settingsTab.screenKey -> settingsTab
                debugTab.screenKey -> debugTab
                else -> shoppingListTab
            }
        )
        view.setOnApplyWindowInsetsListener { _, insets ->
            presenter.showHideNavBar(insets.systemWindowInsetBottom == 0)
            insets
        }
    }

    override fun installModules(scope: Scope) {
        super.installModules(scope)
        scope.installModule {
            val wootric = Wootric.init(requireActivity(), BuildConfig.WOOTRIC_CLIENT_ID, BuildConfig.WOOTRIC_TOKEN)
            bind<Wootric>().toInstance(wootric)
            bind<UserInfoProvider>().toClass<UserInfoProviderImpl>().singleton()
        }
    }

    override fun onResume() {
        super.onResume()
        requireView().postSelf {
            context.getSystemService<ClipboardManager>()?.run {
                val clip = primaryClip?.apply {
                    if (itemCount > 0) {
                        presenter.getDataFromClipboard(getItemAt(0).text)
                    }
                }
                if (clip != null) {
                    primaryClip = clip
                }
            }
        }
        presenter.onResume()
    }

    override fun showNotARecipeUrl() {
        NotARecipeBottomSheetDialogFragment.showNow(this)
    }

    override fun showSaveRecipeNotification(possibleUrl: String, duration: Int) {
        val text = buildSpannedString {
            append(getString(R.string.recipes_save_link_from_clipboard))
            append("\n")
            color(requireContext(), R.color.gray82) {
                append(possibleUrl)
            }
        }
        NotificationHelper.showSnackBarNotification(
            view = findInnerCoordinator() ?: container,
            message = SystemMessage.Notification(
                text = text,
                duration = Duration.CUSTOM(duration),
                actionText = getString(R.string.btn_save),
                actionListener = presenter::openRecipeBuilder
            )
        )
    }

    private fun findInnerCoordinator(): CoordinatorLayout? {
        return (currentTabFragment?.requireView() as? ViewGroup)?.run {
            findInnerCoordinatorRecursively(this)
        }
    }

    private fun findInnerCoordinatorRecursively(viewGroup: ViewGroup): CoordinatorLayout? {
        var coordinator: CoordinatorLayout? = null
        viewGroup.forEach {
            if (it is ViewGroup) {
                if (it is CoordinatorLayout) {
                    coordinator = it
                }
                val coordinatorLayout = findInnerCoordinatorRecursively(it)
                if (coordinatorLayout != null) {
                    coordinator = coordinatorLayout
                }
            }
        }
        return coordinator
    }

    override fun onBackPressed() {
        currentTabFragment?.onBackPressed()
    }

    private fun configureBottomTabs() {
        bottomNavigationView.menu.findItem(R.id.tab_debug).isVisible = BuildConfig.DEBUG
        bottomNavigationView.setOnNavigationItemSelectedListener {
            when (it.itemId) {
                R.id.tab_shopping_lists -> presenter.openShoppingLists()
                R.id.tab_recipes_list -> presenter.openRecipes()
                R.id.tab_settings -> presenter.openSettings()
                R.id.tab_debug -> selectTab(debugTab)
            }
            true
        }
    }

    private fun selectTab(tab: SupportAppScreen) {
        val currentFragment = currentTabFragment
        val newFragment = childFragmentManager.findFragmentByTag(tab.screenKey)

        if (currentFragment != null && newFragment != null && currentFragment == newFragment) {
            return
        }

        childFragmentManager.beginTransaction().apply {
            if (newFragment == null) {
                add(R.id.container, createTabFragment(tab), tab.screenKey)
            }

            currentFragment?.let {
                hide(it)
                setMaxLifecycle(it, Lifecycle.State.STARTED)
            }
            newFragment?.let {
                show(it)
                setMaxLifecycle(it, Lifecycle.State.RESUMED)
            }
        }.commitNow()
    }

    private fun createTabFragment(tab: SupportAppScreen) = tab.fragment

    override fun openShoppingList() {
        selectTab(shoppingListTab)
        reselectTab(R.id.tab_shopping_lists)
    }

    override fun openRecipeBox() {
        selectTab(recipesListTab)
        reselectTab(R.id.tab_recipes_list)
    }

    override fun openSettings() {
        selectTab(settingsTab)
        reselectTab(R.id.tab_settings)
    }

    private fun reselectTab(id: Int) {
        val item = bottomNavigationView.menu.findItem(id)
        if (!item.isChecked) {
            item.isChecked = true
        }
    }

    override fun showNavBar() {
        bottomNavigationView.visible()
    }

    override fun hideNavBar() {
        bottomNavigationView.gone()
    }

    companion object {
        private val shoppingListTab = MainFlowScreens.ShoppingList
        private val recipesListTab = MainFlowScreens.RecipesList
        private val settingsTab = MainFlowScreens.Settings
        private val debugTab = MainFlowScreens.Debug
    }
}