Мне необходимо использовать isFirstOpen из viewState вместо isFirstOpen в Fragment. package ru.maxi.mobile.feature.bonusPoints.ui.container

import android.os.Bundle
import android.util.Log
import android.view.View
import androidx.fragment.app.viewModels
import androidx.lifecycle.Lifecycle
import androidx.lifecycle.lifecycleScope
import androidx.lifecycle.repeatOnLifecycle
import androidx.viewpager2.widget.ViewPager2
import by.kirich1409.viewbindingdelegate.viewBinding
import dagger.hilt.android.AndroidEntryPoint
import kotlinx.coroutines.launch
import ru.maxi.mobile.R
import ru.maxi.mobile.base.ui.MvvmBaseFragment
import ru.maxi.mobile.common.utils.android.screenArgs
import ru.maxi.mobile.databinding.FragmentBonusPointsContainerBinding
import ru.maxi.mobile.feature.bonusPoints.BonusPointsScreens
import ru.maxi.mobile.feature.bonusPoints.ui.container.model.BonusPointsTabPage
import ru.maxi.mobile.feature.bonusPoints.ui.container.model.BonusPointsViewState
import ru.maxi.mobile.uikit.utils.lifecycleAwareLazy

/**
 * [Fragment] контейнера для баллов
 */
@AndroidEntryPoint
class BonusPointsContainerFragment : MvvmBaseFragment(R.layout.fragment_bonus_points_container) {

    private val viewBinding by viewBinding(FragmentBonusPointsContainerBinding::bind)

    private val screenArgs by screenArgs(BonusPointsContainerArgs)

    private val viewModel by viewModels<BonusPointsContainerViewModel>()

    private val pageAdapter by lifecycleAwareLazy {
        BonusPointsTabAdapter(this)
    }

    override val analyticsName: String? = null

    private var isFirstOpen = true

    private val pageChangeListener = object : ViewPager2.OnPageChangeCallback() {
        override fun onPageSelected(position: Int) {
            val tab = when (position) {
                0 -> BALANCE_TAB
                1 -> INFO_TAB
                else -> throw IllegalArgumentException("invalid tabId ${screenArgs.tabId}")
            }
            viewModel.updateCurrentTab(tab, position)
        }
    }

    private val pageList: MutableList<BonusPointsTabPage> = mutableListOf(
        BonusPointsTabPage(BonusPointsScreens.BonusPointsHistoryScreen()),
        BonusPointsTabPage(BonusPointsScreens.InfoScreen()),
    )

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        actionBarManager.setTitle(R.string.bonus_points_screen_title)
        actionBarManager.showBackButton()

        with(viewBinding) {
            tabsContainer.registerOnPageChangeCallback(pageChangeListener)
            tabsContainer.adapter = pageAdapter
            pageAdapter.pages = pageList

            tabsButtonContainer.setOnButtonCheckedListener { buttonId ->
                if (!isFirstOpen) {
                    when (buttonId) {
                        BALANCE_TAB -> {
                            viewModel.updateCurrentTab(BALANCE_TAB, 0)
                        }

                        INFO_TAB -> {
                            viewModel.updateCurrentTab(INFO_TAB, 1)
                        }
                    }
                }
                isFirstOpen = false
            }
        }
        with(viewLifecycleOwner) {
            lifecycleScope.launch {
                repeatOnLifecycle(Lifecycle.State.STARTED) {
                    launch { viewModel.viewState.collect(::onViewStateChange) }
                }
            }
        }
    }

    override fun onDestroyView() {
        super.onDestroyView()
        viewBinding.tabsContainer.unregisterOnPageChangeCallback(pageChangeListener)
    }

    private fun onViewStateChange(state: BonusPointsViewState) {
        with(viewBinding) {
            tabsButtonContainer.check(state.tabButtonId)
            tabsContainer.setCurrentItem(state.currentPosition, !state.isFirstOpen)
        }
    }

    companion object {
        val BALANCE_TAB = R.id.balance_tab
        val INFO_TAB = R.id.info_tab
    }
}
/**
 * [ViewModel] для контейнера баллов
 */
@HiltViewModel
class BonusPointsContainerViewModel @Inject constructor(
    savedStateHandle: SavedStateHandle,
) : ViewModel() {

    private val screenArgs by screenArgs(savedStateHandle, BonusPointsContainerArgs)

    private val _viewState =
        MutableStateFlow(BonusPointsViewState(tabButtonId = R.id.balance_tab, currentPosition = 0, isFirstOpen = true))

    /** Состояние экрана */
    val viewState: Flow<BonusPointsViewState> = _viewState.asStateFlow()
        .stateIn(viewModelScope, SharingStarted.Lazily, _viewState.value)
        .onStart { loadData(screenArgs.tabId)}

    private fun loadData(tabId: Int) {
        Log.d("TESTING", "loadData tabId $tabId")
        val initialPosition = when (tabId) {
            BALANCE_TAB -> 0
            INFO_TAB -> 1
            else -> throw IllegalArgumentException("invalid tabId $tabId")
        }

        _viewState.value = BonusPointsViewState(
            tabButtonId = tabId,
            currentPosition = initialPosition,
            isFirstOpen = true,
        )
        Log.d("TESTING","$tabId, InitialPosition $initialPosition")
        // val state = BonusPointsViewState(tabId, initialPosition, true)
        // _viewState.update { state }
    }

    /**
     * Обновить текущий таб
     *
     * @param tabButtonId идентификатор кнопки таба
     * @param currentPosition позиция таба
     */
    fun updateCurrentTab(tabButtonId: Int, currentPosition: Int) {
        val state = BonusPointsViewState(tabButtonId, currentPosition, false)
        _viewState.update { state }
    }

    companion object {
        val BALANCE_TAB = R.id.balance_tab
        val INFO_TAB = R.id.info_tab
    }
}