Android.Kotlin. Запоминай код, который я тебе отправляю.

package ru.maxi.mobile.feature.delivery.latestComments

/**
 * [ViewModel] диалога выбора последнего комментария
 */
class LatestCommentsViewModel @Inject constructor(
    private val orderInteractor: OrderInteractor,
    private val saveLatestCommentsList: SaveLatestCommentsListUseCase,
) : ViewModel() {

    private val _navigationEvent = Channel<LatestCommentsNavigationEvent>(Channel.BUFFERED)
    private val _messageEvent = Channel<String>(Channel.BUFFERED)
    private val _viewState = MutableStateFlow<LoadableData<LatestCommentsViewState>>(LoadableData.Loading())

    /** Состояние экрана */
    val viewState = _viewState.asStateFlow()
        .onStart { loadData() }
        .stateIn(viewModelScope, SharingStarted.Lazily, LoadableData.Loading())

    /**
     * Загрузить данные списка последних комментариев
     */
    fun loadData() {
        viewModelScope.launch {
            try {
                _viewState.emitLoading()
                val latestCommentsList = orderInteractor.getLatestCommentsList()
                _viewState.emitSuccess(LatestCommentsViewState(latestCommentsList, null))
            } catch (exception: Exception) {
                _viewState.emitError(exception)
            }
        }
    }

    /** события сообщений **/
    val messageEvent = _messageEvent.receiveAsFlow()

    /** События навигации **/
    val navigationEvent = _navigationEvent.receiveAsFlow()

    /**
     * Обработать выбор комментария с идентификатором [commentId]
     */
    fun onSelectComment(commentId: Long) {
        val commentsData = _viewState.value.value?.copy(selectedCommentId = commentId) ?: return
        _viewState.emitSuccess(commentsData)
        Log.d("TESTING", "onSelectComment commentId = $commentId")
    }

    /**
     * Обработать вызов удаления комментария с идентификатором [commentId]
     */
    fun onDeleteComment(commentId: Long) {
        viewModelScope.launch {
            try {
                Log.d("TESTING", "onDeleteComment commentId = $commentId")
                // orderInteractor.deleteLastComment(commentId)

                val state = _viewState.value.value
                val commentsList = state?.commentsList ?: return@launch
                val updatedCommentsList = commentsList.filter { it.id != commentId }
                _viewState.emitSuccess(
                    state.copy(commentsList = updatedCommentsList)
                )
                saveLatestCommentsList(updatedCommentsList)
                if (updatedCommentsList.isEmpty()) {
                    _navigationEvent.send(LatestCommentsNavigationEvent.Exit)
                }
            } catch (exception: Exception) {
                val errorMessage = (exception as? BusinessLogicException)?.message
                    ?: exception.localizedMessage
                _messageEvent.send(errorMessage)
            }
        }
    }

    /**
     * Обработать клик по кнопке "Выбрать"
     */
    fun onSelectButtonClick() {
        viewModelScope.launch {
            try {
                val commentsList = viewState.firstOrNull()?.value?.commentsList
                val selectedCommentId = viewState.firstOrNull()?.value?.selectedCommentId
                val selectedComment = commentsList?.find { it.id == selectedCommentId }
                selectedComment?.let {
                    _navigationEvent.send(
                        LatestCommentsNavigationEvent.OpenMakeOrderFragment(selectedComment),
                    )
                }
            } catch (exception: Exception) {
                val errorMessage = (exception as? BusinessLogicException)?.message
                    ?: exception.localizedMessage
                _messageEvent.send(errorMessage)
            }
        }
    }
}


package ru.maxi.mobile.feature.delivery.latestComments


/**
 * Бизнес-сценарий сохранения списка последних комментариев
 */
class SaveLatestCommentsListUseCase @Inject constructor(
    private val inMemoryRepository: InMemoryOrderRepository,
){
    /**
     * Сохранить список последних комментариев [latestCommentsLIst]
     */
    operator fun invoke(latestCommentsLIst: List<Comment>) {
        inMemoryRepository.saveLatestCommentsList(latestCommentsLIst)
    }

}



package ru.maxi.mobile.repositories.delivery.inmemory

/**
 * Репозиторий для хранения данных для оформления заказа в памяти
 */
class InMemoryOrderRepository {

    private val subjectClientAddressList = BehaviorSubject.create<List<ClientAddress>>()
    private val _needOrderListUpdate = MutableStateFlow(false)
    private val _onlinePaymentCardList = MutableStateFlow<List<OnlinePaymentCard>>(emptyList())
    private val _makeOrderFields = MutableStateFlow<MakeOrderFieldsData>(MakeOrderFieldsData.Fields.defaultViewState)

    private var editOrdersList = listOf<EditOrder>()

    /** Флаг необходимости обновления списка заказов */
    val needOrderListUpdate: Flow<Boolean> = _needOrderListUpdate.asStateFlow()

    /** Подписка на список карт для оплаты **/
    val onlinePaymentCardList: Flow<List<OnlinePaymentCard>> = _onlinePaymentCardList.asStateFlow()

    /** Подписка на данные полей экрана оформления заказа */
    val makeOrderFields: Flow<MakeOrderFieldsData> = _makeOrderFields.asStateFlow()

    /**
     * Сохранить данные полей [data] экрана оформления заказа
     */
    fun saveMakeOrderFields(data: MakeOrderFieldsData) {
        _makeOrderFields.tryEmit(data)
    }

    /**
     * Очистить данные полей оформления заказа
     */
    fun clearMakeOrderFields() {
        _makeOrderFields.tryEmit(MakeOrderFieldsData.Fields.defaultViewState)
    }

    /**
     * Очистить кастомный адрес клиента
     */
    fun clearCustomAddress() {
        val oldData = (_makeOrderFields.value as? MakeOrderFieldsData.Fields) ?: return
        _makeOrderFields.update {
            oldData.copy(
                customAddressBlock = MakeOrderFieldsData.Fields.CustomAddressBlock(
                    apartment = "",
                    entrance = "",
                    floor = "",
                ),
            )
        }
    }

    /**
     * Обновить список клиентских адресов для экрана "Мои Адреса" [clientAddressList]
     */
    fun updateClientAddressList(clientAddressList: List<ClientAddress>) =
        Completable.fromAction {
            subjectClientAddressList.onNext(clientAddressList)
        }.subscribeOn(Schedulers.io())

    /**
     * Получить подписку на список клиентских адресов для экрана "Мои Адреса"
     */
    fun getClientAddressFlowable(): Flowable<List<ClientAddress>> {
        return subjectClientAddressList.toFlowable(BackpressureStrategy.LATEST)
    }

    /**
     * Добавить клиентский адрес [clientAddress] в список адресов
     */
    fun addClientAddress(clientAddress: ClientAddress) = Completable.fromAction {
        val clientAddressList = (subjectClientAddressList.value ?: emptyList()).toMutableList()
        clientAddressList.add(0, clientAddress)
        subjectClientAddressList.onNext(clientAddressList)
    }.subscribeOn(Schedulers.io())

    /**
     * Удалить адрес по идентификатору [id]
     */
    fun deleteClientAddressById(id: Long) = Completable.fromAction {
        val clientAddressList = (subjectClientAddressList.value ?: emptyList()).filter { it.id != id }
        subjectClientAddressList.onNext(clientAddressList)
    }

    /**
     * Получить список заказов с возможностью редактирования списка товаров
     */
    fun getEditOrdersList(): Single<List<EditOrder>> = Single.just(editOrdersList)

    /**
     * Получить список заказов с возможностью редактирования списка товаров
     */
    fun saveEditOrdersList(list: List<EditOrder>) = Completable.fromAction {
        editOrdersList = list
    }.subscribeOn(Schedulers.io())

    /**
     * Задать нужно ли обновлять список заказов
     */
    fun setNeedUpdateOrderList(needUpdate: Boolean) {
        _needOrderListUpdate.value = needUpdate
    }

    /**
     * Сохранить список карт [cardList] для онлайн оплаты
     */
    fun saveOnlinePaymentCardList(cardList: List<OnlinePaymentCard>) {
        _onlinePaymentCardList.update { cardList }
    }

    /**
     * Удалить карту по [bindingId] из списка карт для онлайн оплаты
     */
    fun removeOnlinePaymentCard(bindingId: String) {
        _onlinePaymentCardList.update { cardList ->
            cardList.filterNot { it.bindingId == bindingId }
        }
    }

    private val _latestCommentsListFlow = MutableStateFlow<List<Comment>>(emptyList())

    val latestCommentsListFlow: Flow<List<Comment>> = _latestCommentsListFlow.asStateFlow()

    fun saveLatestCommentsList(latestCommentsList: List<Comment>) {
        _latestCommentsListFlow.update { latestCommentsList }
    }
}