abstract class HomeController : BindingController, Toolbar.OnMenuItemClickListener {

    var alertDialog: AlertDialog? = null
    var snackBar: Snackbar? = null

    private lateinit var binding: AppToolbarBinding
    private lateinit var bindingCentered: AppToolbarCenteredBinding
    private var isCentered = false
    private var isToolbar = false
    lateinit var userViewModel: UserViewModel
    lateinit var jobViewModel: JobViewModel
    lateinit var activityLogViewModel: ActivityLogViewModel
    lateinit var preferences: SharedPreferences
    lateinit var navigateViewModel: NavigateViewModel

    @Inject
    lateinit var analyticsTracker: AnalyticsTracker

    @Inject
    lateinit var accountManager: UserAccountManager

    private var userInfo: User? = null

    constructor(args: Bundle?) : super(args)
    constructor() : super(null)

    override fun inject(controllerComponent: ControllerComponent) {
        controllerComponent.inject(this)
    }

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup,
        savedViewState: Bundle?,
    ): View {
        preferences = (activity as HomeActivity).getSharedPreferences(
            "ProCrewz",
            AppCompatActivity.MODE_PRIVATE
        )

        userViewModel =
            ViewModelProvider((activity as ViewModelStoreOwner))[UserViewModel::class.java]
        jobViewModel =
            ViewModelProvider((activity as ViewModelStoreOwner))[JobViewModel::class.java]
        activityLogViewModel =
            ViewModelProvider((activity as ViewModelStoreOwner))[ActivityLogViewModel::class.java]

        navigateViewModel =
            ViewModelProvider((activity as ViewModelStoreOwner))[NavigateViewModel::class.java]
        return super.onCreateView(inflater, container, savedViewState)
    }

    override fun onViewBound(view: View) {
        setUserObserver()
    }

    private fun setUserObserver() {
        userViewModel.userNetworkState.observe((activity as LifecycleOwner)) {
            when (it) {
                is NetworkDataState.Success -> {
                    userData(it.data)
                    val avatar = it.data.photoUrl
                    if (isToolbar && avatar != null) {
                        try {
                            if (isCentered) {
                                bindingCentered.toolbarProfile.setImage(avatar)
                                bindingCentered.toolbarProfile.setOnClickListener { launchProfile() }
                            } else {
                                binding.toolbarProfile.setImage(avatar)
                                binding.toolbarProfile.setOnClickListener { launchProfile() }
                            }
                        } catch (e: IllegalArgumentException) {
                            analyticsTracker.logEvent(
                                "error",
                                BundleBuilder(Bundle())
                                    .putString("exception", "IllegalArgumentException")
                                    .putString("endpoint", "v2/users")
                                    .putString("error_message", e.message)
                                    .build()
                            )
                        }
                    }
                }

                is NetworkDataState.Error -> {
                    analyticsTracker.logEvent(
                        "HttpException",
                        BundleBuilder(Bundle())
                            .putString("endpoint", "v2/users")
                            .putString("message", it.data.facingMessage)
                            .putString("function", "setUserObserver")
                            .build()
                    )
                }

                is NetworkDataState.Loading -> {
                }
            }
        }
    }

    fun refreshToken() {
        val account = accountManager.currentAccount
        val currentUser = SalesforceSDKManager.getInstance().userAccountManager.currentUser

        var refreshToken: String?
        var tokenResponse: OAuth2.TokenEndpointResponse? = null
        if (account != null) {
            CoroutineScope(Dispatchers.IO).launch {
                if (currentUser == null) {
                    val mgr = AccountManager.get(applicationContext)
                    val encryptionKey = SalesforceSDKManager.encryptionKey
                    refreshToken =
                        SalesforceSDKManager.decrypt(mgr.getPassword(account), encryptionKey)
                    val clientId = SalesforceSDKManager.decrypt(
                        mgr.getUserData(
                            account,
                            AuthenticatorService.KEY_CLIENT_ID
                        ),
                        encryptionKey
                    )
                    val addlParamsMap =
                        SalesforceSDKManager.getInstance().loginOptions.additionalParameters
                    val loginServer = SalesforceSDKManager.decrypt(
                        mgr.getUserData(
                            account,
                            AuthenticatorService.KEY_LOGIN_URL
                        ),
                        encryptionKey
                    )

                    tokenResponse = OAuth2.refreshAuthToken(
                        HttpAccess.DEFAULT,
                        URI(loginServer),
                        clientId,
                        refreshToken,
                        addlParamsMap
                    )
                }
            }
        }

        if (tokenResponse != null && tokenResponse!!.refreshToken == null) {
            logout()
        } else {
            FirebaseMessaging.getInstance().token.addOnSuccessListener { result ->
                Timber.d("registering push token: %s", result)

                if (currentUser != null && activity != null) {
                    PushMessaging.setRegistrationId(activity!!, result, currentUser)
                    PushMessaging.registerSFDCPush(activity!!, currentUser)
                } else {
                    accountManager.signoutCurrentUser(router.activity, false)
                }
            }
        }
    }

    open fun logout() {
        SalesforceSDKManager.getInstance().userAccountManager.clearCachedCurrentUser()
        val account = accountManager.currentUser
        if (activity != null) {
            PushMessaging.unregister(activity!!, account, true)
        }
        accountManager.signoutCurrentUser(router.activity, false)
    }

    open fun userData(user: User) {
        userInfo = user
    }

    override fun onMenuItemClick(item: MenuItem): Boolean {
        return false
    }

    protected fun setToolbarNav(navIcon: Int, clickListener: View.OnClickListener?) {
        if (isCentered) {
            bindingCentered.toolbarLogo.setImageResource(navIcon)
            bindingCentered.toolbarLogo.setOnClickListener(clickListener)
        } else {
            binding.toolbarLogo.setImageResource(navIcon)
            binding.toolbarLogo.setOnClickListener(clickListener)
        }
    }

    protected val toolbarMenu: Menu
        get() = if (isCentered) {
            bindingCentered.appToolbarCentered.menu
        } else {
            binding.appToolbarCentered.menu
        }

    protected fun setToolbarBinding(toolbar: AppToolbarBinding?) {
        if (toolbar != null) {
            binding = toolbar
        }
        isToolbar = true
        isCentered = false
        setUserObserver()
    }

    protected fun setToolbarCenteredBinding(toolbar: AppToolbarCenteredBinding?) {
        if (toolbar != null) {
            bindingCentered = toolbar
        }
        isToolbar = true
        isCentered = true
        setUserObserver()
    }

    protected fun setToolbarMenu(menu: Int) {
        if (isCentered) {
            bindingCentered.appToolbarCentered.inflateMenu(menu)
            bindingCentered.appToolbarCentered.setOnMenuItemClickListener(this)
        } else {
            binding.appToolbarCentered.inflateMenu(menu)
            binding.appToolbarCentered.setOnMenuItemClickListener(this)
        }
    }

    protected fun setToolbarTitle(titleId: Int) {
        if (isCentered) {
            bindingCentered.toolbarTitle.setText(titleId)
        } else {
            binding.toolbarTitle.setText(titleId)
        }
    }

    protected fun setToolbarTitle(title: String?) {
        if (isCentered) {
            bindingCentered.toolbarTitle.text = title
        } else {
            binding.toolbarTitle.text = title
        }
    }

    protected fun setToolbarTitleClickListener(clickListener: View.OnClickListener?) {
        if (isCentered) {
            bindingCentered.toolbarTitle.setOnClickListener(clickListener)
        } else {
            binding.toolbarTitle.setOnClickListener(clickListener)
        }
    }

    protected fun setToolbarLogo() {
        if (isCentered) {
            bindingCentered.toolbarLogo.setOnClickListener { launchJobs() }
        } else {
            binding.toolbarLogo.setOnClickListener { launchJobs() }
        }
    }


    private fun launchProfile() {
        router.popToRoot()
        val backStackProvider = EditProfileBackstackProvider()
        val backStack = backStackProvider.backstack
        if (backStack.isNotEmpty()) {
            val fullBackStack = ArrayList<RouterTransaction>().apply {
                addAll(router.backstack.reversed())
                addAll(backStack)
            }
            router.setBackstack(fullBackStack, SimpleSwapChangeHandler())
        }
        val homeActivity = (activity as HomeActivity?)!!
        homeActivity.updateBottomNav(bottomNavId = MORE_VIEW)
    }

    private fun launchJobs() {
        router.popToRoot()
        val homeActivity = (activity as HomeActivity?)!!
        homeActivity.navigateToJobs()

    }

    fun checkPermissions() {
        val homeActivity = activity as? HomeActivity
        if (homeActivity == null || homeActivity.isFinishing) return

        if (ActivityCompat.checkSelfPermission(
                homeActivity,
                Manifest.permission.WRITE_CALENDAR
            ) != PackageManager.PERMISSION_GRANTED ||
            ActivityCompat.checkSelfPermission(
                homeActivity,
                Manifest.permission.POST_NOTIFICATIONS
            ) == PackageManager.PERMISSION_GRANTED
        ) {
            val scheduleFragment = CalendarConfigurationFragment.newInstance(true)
            scheduleFragment.show(homeActivity.supportFragmentManager, "")
        }
    }

    fun showBottomNavBar(b: Boolean) {
        val homeActivity = (activity as HomeActivity?)!!
        homeActivity.showBottomNavBar(b)
    }
    protected fun showAlert(response: NetworkDataStringResponse, invoke: (() -> Unit?)? = null) {
        val alertDialogParams = AlertDialogParams(
            titleString = response.title ?: response.facingMessage,
            messageString = response.facingMessage,
            onPositiveClicked = {
                if (invoke != null) {
                    invoke()
                }
            }
        )

        withActivity {
            alertDialog?.dismiss()
            alertDialog = it.createAlert(alertDialogParams)
            alertDialog?.show()
        }
    }

    private fun Context.createAlert(params: AlertDialogParams): AlertDialog {
        val alertDialogBuilder = AlertDialog.Builder(this)
            .setTitle(
                params.titleString ?: this.resources?.getString(R.string.something_went_wrong_label)
            )
            .setMessage(params.messageString)
            .setCancelable(false)
            .setPositiveButton(params.positiveButtonTextRes) { dialog, _ ->
                dialog.dismiss()
                params.onPositiveClicked()
            }

        params.negativeButtonTextRes?.let { negativeText ->
            alertDialogBuilder.setNegativeButton(negativeText) { dialog, _ ->
                dialog.dismiss()
                params.onNegativeClicked?.let { it() }
            }
        }

        return alertDialogBuilder.create()
    }

    protected fun dismissAlert() {
        alertDialog?.dismiss()
    }


    fun updateBottomNav(bottomNavId: Int? = null, badgeCount: Int? = null) {
        val homeActivity = (activity as HomeActivity?)!!
        homeActivity.updateBottomNav(bottomNavId = bottomNavId, badgeCount = badgeCount)

    }

    companion object {
        const val CLASS_NAME = "HomeController"
    }
}

@Parcelize
data class User(
    @SerializedName("accountId")
    var accountId: String? = null,
    @SerializedName("certificationAlertCount")
    var certificationAlertCount: Int = 0,
    @SerializedName("certifications")
    var certifications: ArrayList<Certification>? = null,
    @SerializedName("changeRequests")
    var changeRequests: ArrayList<ChangeRequest>? = null,
    @SerializedName("contact")
    var contact: Contact? = null,
    @SerializedName("emergencyContacts")
    var emergencyContacts: ArrayList<EmergencyContact>? = null,
    @SerializedName("campaignEnrollments")
    var campaignEnrollments: ArrayList<Campaign>? = null,
    @SerializedName("legal")
    var legal: Legal? = null,
    @SerializedName("mailingAddress")
    var mailingAddress: MailingAddress? = null,
    @SerializedName("name")
    var name: String? = null,
    @SerializedName("firstName")
    var firstName: String? = null,
    @SerializedName("lastName")
    var lastName: String? = null,
    @SerializedName("pendingAccountDeletion")
    var pendingAccountDeletion: Boolean? = null,
    @SerializedName("pendingChangeRequestsCount")
    var pendingChangeRequestsCount: Int = 0,
    @SerializedName("photoUrl")
    var photoUrl: String? = null,
    @SerializedName("support")
    var support: Support? = null,
    @SerializedName("userId")
    var userId: String? = null,
    @SerializedName("image")
    var image: String? = null,
    @SerializedName("calendarSyncEnabled")
    var calendarSyncEnabled: Boolean = false,
    @SerializedName("entities")
    var entities: ArrayList<Entity>? = null,
) : Parcelable