DialogViewModel.Handle.cs

//
// Copyright Fela Ameghino & Contributors 2015-2025
//
// Distributed under the GNU General Public License v3.0. (See accompanying
// file LICENSE or copy at https://www.gnu.org/licenses/gpl-3.0.txt)
//
using System;
using System.Collections.Generic;
using System.Linq;
using Telegram.Collections;
using Telegram.Common;
using Telegram.Controls;
using Telegram.Controls.Messages;
using Telegram.Controls.Messages.Content;
using Telegram.Services;
using Telegram.Td.Api;
using Windows.UI.Core;
using Windows.UI.Xaml;

namespace Telegram.ViewModels
{
    public partial class DialogViewModel : IHandle
    {
        public override void Subscribe()
        {
            Aggregator.Subscribe<UpdateChatSwitchInlineQuery>(this, Handle)
                .Subscribe<UpdateChatActiveStories>(Handle)
                .Subscribe<UpdateChatPermissions>(Handle)
                .Subscribe<UpdateChatReplyMarkup>(Handle)
                .Subscribe<UpdateChatUnreadMentionCount>(Handle)
                .Subscribe<UpdateChatUnreadReactionCount>(Handle)
                .Subscribe<UpdateChatReadOutbox>(Handle)
                .Subscribe<UpdateForumTopicReadOutbox>(Handle)
                .Subscribe<UpdateChatReadInbox>(Handle)
                .Subscribe<UpdateChatDraftMessage>(Handle)
                .Subscribe<UpdateChatDefaultDisableNotification>(Handle)
                .Subscribe<UpdateChatMessageSender>(Handle)
                .Subscribe<UpdateChatActionBar>(Handle)
                .Subscribe<UpdateChatIsTranslatable>(Handle)
                .Subscribe<UpdateChatHasScheduledMessages>(Handle)
                .Subscribe<UpdateChatVideoChat>(Handle)
                .Subscribe<UpdateChatPendingJoinRequests>(Handle)
                .Subscribe<UpdateChatAction>(Handle)
                .Subscribe<UpdateChatLastMessage>(Handle)
                .Subscribe<UpdateChatBusinessBotManageBar>(Handle)
                .Subscribe<UpdateNewMessage>(Handle)
                .Subscribe<UpdateDeleteMessages>(Handle)
                .Subscribe<UpdateMessageContent>(Handle)
                .Subscribe<UpdateMessageContentOpened>(Handle)
                .Subscribe<UpdateMessageMentionRead>(Handle)
                .Subscribe<UpdateMessageUnreadReactions>(Handle)
                .Subscribe<UpdateMessageEdited>(Handle)
                .Subscribe<UpdateMessageInteractionInfo>(Handle)
                .Subscribe<UpdateMessageIsPinned>(Handle)
                .Subscribe<UpdateMessageSendFailed>(Handle)
                .Subscribe<UpdateMessageSendSucceeded>(Handle)
                .Subscribe<UpdateMessageTranslatedText>(Handle)
                .Subscribe<UpdateMessageFactCheck>(Handle)
                .Subscribe<UpdateMessageEffect>(Handle)
                .Subscribe<UpdateAnimatedEmojiMessageClicked>(Handle)
                .Subscribe<UpdateUser>(Handle)
                .Subscribe<UpdateUserFullInfo>(Handle)
                .Subscribe<UpdateSecretChat>(Handle)
                .Subscribe<UpdateBasicGroup>(Handle)
                .Subscribe<UpdateBasicGroupFullInfo>(Handle)
                .Subscribe<UpdateSupergroup>(Handle)
                .Subscribe<UpdateSupergroupFullInfo>(Handle)
                .Subscribe<UpdateUserStatus>(Handle)
                .Subscribe<UpdateChatTitle>(Handle)
                .Subscribe<UpdateChatPhoto>(Handle)
                .Subscribe<UpdateChatEmojiStatus>(Handle)
                .Subscribe<UpdateChatTheme>(Handle)
                .Subscribe<UpdateChatBackground>(Handle)
                .Subscribe<UpdateChatNotificationSettings>(Handle)
                .Subscribe<UpdateChatOnlineMemberCount>(Handle)
                .Subscribe<UpdateChatVideoChat>(Handle)
                .Subscribe<UpdateGroupCall>(Handle)
                .Subscribe<UpdateSpeechRecognitionTrial>(Handle)
                .Subscribe<UpdateSavedMessagesTags>(Handle)
                .Subscribe<UpdateGreetingSticker>(Handle)
                .Subscribe<UpdateQuickReplyShortcut>(Handle);
        }

        public void Handle(UpdateQuickReplyShortcut update)
        {
            if (QuickReplyShortcut?.Name == update.Shortcut.Name)
            {
                BeginOnUIThread(() => QuickReplyShortcut = update.Shortcut);
            }
        }

        public void Handle(UpdateGreetingSticker update)
        {
            if (_greetingSticker == null)
            {
                BeginOnUIThread(() => GreetingSticker = update.Sticker);
            }
        }

        public void Handle(UpdateSpeechRecognitionTrial update)
        {
            if (_needsUpdateSpeechRecognitionTrial)
            {
                _needsUpdateSpeechRecognitionTrial = false;
                BeginOnUIThread(() => ShowSpeechRecognitionTrial(update.LeftCount > 0 ? 1 : 2));
            }
        }

        public void Handle(UpdateSavedMessagesTags update)
        {
            if (_chat?.Id == ClientService.Options.MyId)
            {
                //if (update.SavedMessagesTopic.AreTheSame(_savedMessagesTopic))
                //{
                //    BeginOnUIThread(() => SavedMessagesTags = update.Tags);
                //}
                //else
                {
                    ClientService.Send(new GetSavedMessagesTags(SavedMessagesTopicId), result =>
                    {
                        if (result is SavedMessagesTags tags)
                        {
                            BeginOnUIThread(() => SavedMessagesTags = tags);
                        }
                    });
                }
            }
        }

        public void Handle(UpdateChatAction update)
        {
            if (update.ChatId == _chat?.Id && update.MessageThreadId == OutgoingThreadId && _type is DialogType.History or DialogType.Thread)
            {
                BeginOnUIThread(() => Delegate?.UpdateChatActions(_chat, ClientService.GetChatActions(update.ChatId)));
            }
        }

        public void Handle(UpdateChatBusinessBotManageBar update)
        {
            if (update.ChatId == _chat?.Id && _type == DialogType.History)
            {
                BeginOnUIThread(() => Delegate?.UpdateChatBusinessBotManageBar(_chat, update.BusinessBotManageBar));
            }
        }

        #region Generic

        public void Handle(UpdateUser update)
        {
            var chat = _chat;
            if (chat == null)
            {
                return;
            }

            if (chat.Type is ChatTypePrivate privata && privata.UserId == update.User.Id)
            {
                BeginOnUIThread(() => Delegate?.UpdateUserFullInfo(chat, update.User, ClientService.GetUserFull(update.User.Id), false, _accessToken != null));
            }
            else if (chat.Type is ChatTypeSecret secret && secret.UserId == update.User.Id)
            {
                BeginOnUIThread(() => Delegate?.UpdateUserFullInfo(chat, update.User, ClientService.GetUserFull(update.User.Id), true, false));
            }
        }

        public void Handle(UpdateUserFullInfo update)
        {
            var chat = _chat;
            if (chat == null)
            {
                return;
            }

            if (chat.Type is ChatTypePrivate privata && privata.UserId == update.UserId && ClientService.TryGetUser(update.UserId, out User user))
            {
                UpdateEmptyState(user, update.UserFullInfo, true);
                BeginOnUIThread(() => Delegate?.UpdateUserFullInfo(chat, user, update.UserFullInfo, false, _accessToken != null));
            }
            else if (chat.Type is ChatTypeSecret secret && secret.UserId == update.UserId)
            {
                BeginOnUIThread(() => Delegate?.UpdateUserFullInfo(chat, ClientService.GetUser(update.UserId), update.UserFullInfo, true, false));
            }
        }

        public void Handle(UpdateSecretChat update)
        {
            var chat = _chat;
            if (chat == null)
            {
                return;
            }

            if (chat.Type is ChatTypeSecret secret && secret.SecretChatId == update.SecretChat.Id)
            {
                BeginOnUIThread(() => Delegate?.UpdateSecretChat(chat, update.SecretChat));
            }
        }



        public void Handle(UpdateBasicGroup update)
        {
            var chat = _chat;
            if (chat == null)
            {
                return;
            }

            if (chat.Type is ChatTypeBasicGroup basic && basic.BasicGroupId == update.BasicGroup.Id)
            {
                BeginOnUIThread(() => Delegate?.UpdateBasicGroupFullInfo(chat, update.BasicGroup, ClientService.GetBasicGroupFull(update.BasicGroup.Id)));
            }
        }

        public void Handle(UpdateBasicGroupFullInfo update)
        {
            var chat = _chat;
            if (chat == null)
            {
                return;
            }

            if (chat.Type is ChatTypeBasicGroup basic && basic.BasicGroupId == update.BasicGroupId && ClientService.TryGetBasicGroup(update.BasicGroupId, out BasicGroup basicGroup))
            {
                BeginOnUIThread(() => Delegate?.UpdateBasicGroupFullInfo(chat, basicGroup, update.BasicGroupFullInfo));
            }
        }



        public void Handle(UpdateSupergroup update)
        {
            var chat = _chat;
            if (chat == null)
            {
                return;
            }

            if (chat.Type is ChatTypeSupergroup super && super.SupergroupId == update.Supergroup.Id)
            {
                BeginOnUIThread(() => Delegate?.UpdateSupergroupFullInfo(chat, update.Supergroup, ClientService.GetSupergroupFull(update.Supergroup.Id)));
            }
        }

        public void Handle(UpdateSupergroupFullInfo update)
        {
            var chat = _chat;
            if (chat == null)
            {
                return;
            }

            if (chat.Type is ChatTypeSupergroup super && super.SupergroupId == update.SupergroupId && ClientService.TryGetSupergroup(update.SupergroupId, out Supergroup supergroup))
            {
                BeginOnUIThread(() =>
                {
                    Delegate?.UpdateSupergroupFullInfo(chat, supergroup, update.SupergroupFullInfo);
                });
            }
        }

        public void Handle(UpdateChatVideoChat update)
        {
            if (_chat?.Id == update.ChatId)
            {
                BeginOnUIThread(() => Delegate?.UpdateChatVideoChat(_chat, update.VideoChat));
            }
        }

        public void Handle(UpdateGroupCall update)
        {
            if (_chat?.VideoChat?.GroupCallId == update.GroupCall.Id)
            {
                BeginOnUIThread(() => Delegate?.UpdateGroupCall(_chat, update.GroupCall));
            }
        }

        private async void UpdateGroupCall(Chat chat, int groupCallId)
        {
            if (groupCallId == 0)
            {
                return;
            }

            var response = await ClientService.SendAsync(new GetGroupCall(groupCallId));
            if (response is GroupCall groupCall)
            {
                BeginOnUIThread(() => Delegate?.UpdateGroupCall(chat, groupCall));
            }
        }



        public void Handle(UpdateChatTitle update)
        {
            if (update.ChatId == _chat?.Id)
            {
                BeginOnUIThread(() => Delegate?.UpdateChatTitle(_chat));
            }
        }

        public void Handle(UpdateChatPhoto update)
        {
            if (update.ChatId == _chat?.Id)
            {
                BeginOnUIThread(() => Delegate?.UpdateChatPhoto(_chat));
            }
        }

        public void Handle(UpdateChatEmojiStatus update)
        {
            if (update.ChatId == _chat?.Id)
            {
                BeginOnUIThread(() => Delegate?.UpdateChatEmojiStatus(_chat));
            }
        }

        public void Handle(UpdateChatTheme update)
        {
            if (update.ChatId == _chat?.Id)
            {
                BeginOnUIThread(() => Delegate?.UpdateChatTheme(_chat));
            }
        }

        public void Handle(UpdateChatBackground update)
        {
            if (update.ChatId == _chat?.Id)
            {
                BeginOnUIThread(() => Delegate?.UpdateChatBackground(_chat));
            }
        }

        public void Handle(UpdateUserStatus update)
        {
            if (_chat?.Type is ChatTypePrivate privata && privata.UserId == update.UserId || _chat?.Type is ChatTypeSecret secret && secret.UserId == update.UserId)
            {
                BeginOnUIThread(() => Delegate?.UpdateUserStatus(_chat, ClientService.GetUser(update.UserId)));
            }
        }

        public void Handle(UpdateChatNotificationSettings update)
        {
            if (update.ChatId == _chat?.Id)
            {
                BeginOnUIThread(() => Delegate?.UpdateChatNotificationSettings(_chat));
            }
        }

        public void Handle(UpdateChatOnlineMemberCount update)
        {
            if (update.ChatId == _chat?.Id)
            {
                BeginOnUIThread(() =>
                {
                    if (update.OnlineMemberCount > 1)
                    {
                        OnlineCount = Locale.Declension(Strings.R.OnlineCount, update.OnlineMemberCount);
                    }
                    else
                    {
                        OnlineCount = null;
                    }
                });
            }
        }

        #endregion

        public void Handle(UpdateChatSwitchInlineQuery update)
        {
            if (update.ChatId == _chat?.Id)
            {
                var bot = ClientService.GetUser(update.BotUserId);
                if (bot == null || !bot.HasActiveUsername(out string username))
                {
                    return;
                }

                SetText(string.Format("@{0} {1}", username, update.Query), focus: true);
                ResolveInlineBot(username, update.Query);
            }
        }

        public void Handle(UpdateChatPendingJoinRequests update)
        {
            if (update.ChatId == _chat?.Id)
            {
                BeginOnUIThread(() => Delegate?.UpdateChatPendingJoinRequests(_chat));
            }
        }

        public void Handle(UpdateChatActiveStories update)
        {
            if (update.ActiveStories.ChatId == _chat?.Id)
            {
                BeginOnUIThread(() => Delegate?.UpdateChatActiveStories(_chat));
            }
        }

        public void Handle(UpdateChatPermissions update)
        {
            if (update.ChatId == _chat?.Id)
            {
                BeginOnUIThread(() => Delegate?.UpdateChatPermissions(_chat));
            }
        }

        public void Handle(UpdateChatActionBar update)
        {
            if (update.ChatId == _chat?.Id && _type == DialogType.History)
            {
                BeginOnUIThread(() => UpdateChatActionBar(_chat));
            }
        }

        private void UpdateChatActionBar(Chat chat)
        {
            if (ClientService.TryGetUser(chat, out User user) && chat.ActionBar is ChatActionBarReportAddBlock { AccountInfo: not null })
            {
                ClientService.Send(new GetGroupsInCommon(user.Id, 0, 3), result =>
                {
                    BeginOnUIThread(() => GroupsInCommon = result as Td.Api.Chats);
                });
            }

            Delegate?.UpdateChatActionBar(chat);
        }

        public void Handle(UpdateChatIsTranslatable update)
        {
            if (update.ChatId == _chat?.Id)
            {
                BeginOnUIThread(() => Delegate?.UpdateChatIsTranslatable(_chat, _languageDetected));
            }
        }

        public void Handle(UpdateChatHasScheduledMessages update)
        {
            if (update.ChatId == _chat?.Id)
            {
                BeginOnUIThread(() => Delegate?.UpdateChatHasScheduledMessages(_chat));
            }
        }

        public async void Handle(UpdateChatReplyMarkup update)
        {
            if (update.ChatId == _chat?.Id)
            {
                var response = await ClientService.SendAsync(new GetMessage(update.ChatId, update.ReplyMarkupMessageId));
                if (response is Message message)
                {
                    BeginOnUIThread(() => Delegate?.UpdateChatReplyMarkup(_chat, CreateMessage(message)));
                }
                else
                {
                    BeginOnUIThread(() => Delegate?.UpdateChatReplyMarkup(_chat, null));
                }
            }
        }

        public void Handle(UpdateChatUnreadMentionCount update)
        {
            if (update.ChatId == _chat?.Id)
            {
                BeginOnUIThread(() => Delegate?.UpdateChatUnreadMentionCount(_chat, update.UnreadMentionCount));
            }
        }

        public void Handle(UpdateChatUnreadReactionCount update)
        {
            if (update.ChatId == _chat?.Id)
            {
                BeginOnUIThread(() => Delegate?.UpdateChatUnreadReactionCount(_chat, update.UnreadReactionCount));
            }
        }

        public void Handle(UpdateChatReadOutbox update)
        {
            if (update.ChatId == _chat?.Id && _topic == null)
            {
                BeginOnUIThread(() =>
                {
                    Delegate?.ForEach((bubble, message) => bubble.UpdateMessageState(message));
                });
            }
        }
        public void Handle(UpdateForumTopicReadOutbox update)
        {
            if (update.ChatId == _chat?.Id && update.MessageThreadId == _topic?.Info.MessageThreadId)
            {
                BeginOnUIThread(() =>
                {
                    Delegate?.ForEach((bubble, message) => bubble.UpdateMessageState(message));
                });
            }
        }

        public void Handle(UpdateChatReadInbox update)
        {
            if (update.ChatId == _chat?.Id && _type == DialogType.History)
            {
                BeginOnUIThread(() =>
                {
                    RaisePropertyChanged(nameof(UnreadCount));
                });
            }
        }

        public void Handle(UpdateChatDraftMessage update)
        {
            if (update.ChatId == _chat?.Id)
            {
                var header = _composerHeader;
                if (header?.EditingMessage != null)
                {
                    return;
                }

                BeginOnUIThread(() => ShowDraftMessage(_chat, false));
            }
        }

        public void Handle(UpdateChatDefaultDisableNotification update)
        {
            if (update.ChatId == _chat?.Id)
            {
                BeginOnUIThread(() => Delegate?.UpdateChatDefaultDisableNotification(_chat, update.DefaultDisableNotification));
            }
        }

        public void Handle(UpdateChatMessageSender update)
        {
            if (update.ChatId == _chat?.Id)
            {
                BeginOnUIThread(() => Delegate?.UpdateChatMessageSender(_chat, update.MessageSenderId));
            }
        }



        public void Handle(UpdateChatLastMessage update)
        {
            if (update.ChatId == _chat?.Id && update.LastMessage == null)
            {
                IsFirstSliceLoaded = null;
            }

            if (update.ChatId == _chat?.Id && _chat.Type is ChatTypePrivate privata)
            {
                var user = ClientService.GetUser(privata.UserId);
                if (user == null)
                {
                    return;
                }

                if (user.Type is UserTypeBot && ClientService.TryGetUserFull(user.Id, out UserFullInfo fullInfo))
                {
                    BeginOnUIThread(() => Delegate?.UpdateUserFullInfo(_chat, user, fullInfo, false, _accessToken != null));
                }
                else
                {
                    UpdateEmptyState(user, null, true);
                }
            }
        }

        private void UpdateEmptyState(User user, UserFullInfo fullInfo, bool onlyLocal)
        {
            if (_chat is not Chat chat)
            {
                return;
            }

            var empty = chat.LastMessage == null;
            if (empty && _isChatEmpty)
            {
                return;
            }
            else if (empty == _isChatEmpty && fullInfo == null)
            {
                return;
            }

            _isChatEmpty = empty;

            fullInfo ??= ClientService.GetUserFull(user.Id);

            if (fullInfo == null)
            {
                return;
            }

            if (user.RestrictsNewChats)
            {
                ClientService.Send(new CanSendMessageToUser(user.Id, onlyLocal), result =>
                {
                    BeginOnUIThread(() =>
                    {
                        RestrictsNewChats = result is CanSendMessageToUserResultUserRestrictsNewChats;

                        GreetingSticker ??= ClientService.NextGreetingSticker();
                        Delegate?.UpdateUserRestrictsNewChats(_chat, user, fullInfo, result as CanSendMessageToUserResult);
                    });
                });
            }
            else
            {
                BeginOnUIThread(() =>
                {
                    RestrictsNewChats = false;

                    GreetingSticker ??= ClientService.NextGreetingSticker();
                    Delegate?.UpdateUserRestrictsNewChats(_chat, user, fullInfo, null);
                });
            }
        }

        private bool CheckSchedulingState(Message message)
        {
            if (_type == DialogType.ScheduledMessages)
            {
                return message.SchedulingState != null;
            }
            else if (_type == DialogType.Thread)
            {
                if (_topic != null && _topic.Info.IsGeneral)
                {
                    return message.SchedulingState == null && !message.IsTopicMessage;
                }

                return message.SchedulingState == null && message.MessageThreadId == ThreadId;
            }
            else if (_type == DialogType.SavedMessagesTopic)
            {
                return message.SchedulingState == null && message.SavedMessagesTopicId == SavedMessagesTopicId;
            }
            else if (_type == DialogType.Pinned)
            {
                return message.SchedulingState == null && message.IsPinned;
            }

            return message.SchedulingState == null && _type == DialogType.History;
        }

        public void Handle(UpdateNewMessage update)
        {
            if (update.Message.ChatId == _chat?.Id && CheckSchedulingState(update.Message))
            {
                var message = CreateMessage(update.Message);
                message.GeneratedContentUnread = true;
                message.IsInitial = false;

                BeginOnUIThread(() =>
                {
                    InsertMessage(message);

                    if (!update.Message.IsOutgoing && Settings.Notifications.InAppSounds)
                    {
                        if (NavigationService.Window.ActivationMode != CoreWindowActivationMode.Deactivated)
                        {
                            _notificationsService.PlaySound();
                        }
                    }
                });
            }
        }

        public void Handle(UpdateDeleteMessages update)
        {
            if (update.ChatId == _chat?.Id && !update.FromCache)
            {
                var table = update.MessageIds.ToHashSet();

                BeginOnUIThread(async () =>
                {
                    using (await _loadMoreLock.WaitAsync())
                    {
                        List<MessageViewModel> toBeDeleted = null;

                        for (int i = 0; i < Items.Count; i++)
                        {
                            var message = Items[i];
                            if (message.MediaAlbumId != 0 && message.Content is MessageAlbum album)
                            {
                                var found = false;
                                var invalidated = true;

                                for (int k = 0; k < album.Messages.Count; k++)
                                {
                                    if (table.Contains(album.Messages[k].Id))
                                    {
                                        album.Messages.RemoveAt(k);
                                        k--;

                                        if (album.Messages.Count > 0)
                                        {
                                            message.UpdateWith(album.Messages[0]);
                                            album.Invalidate();
                                        }
                                        else
                                        {
                                            invalidated = false;

                                            _groupedMessages.TryRemove(message.MediaAlbumId, out _);

                                            toBeDeleted ??= new();
                                            toBeDeleted.Add(message);
                                        }

                                        found = true;
                                        //break;
                                    }
                                }

                                if (found)
                                {
                                    if (invalidated)
                                    {
                                        Handle(new UpdateMessageContent(message.ChatId, message.Id, album));
                                    }

                                    continue;
                                }
                            }

                            if (table.Contains(message.Id))
                            {
                                toBeDeleted ??= new();
                                toBeDeleted.Add(message);
                            }
                            else if (message.ReplyTo is MessageReplyToMessage replyToMessage && table.Contains(replyToMessage.MessageId))
                            {
                                message.ReplyToItem = null;
                                message.ReplyToState = MessageReplyToState.Deleted;

                                Handle(message, bubble => bubble.UpdateMessageReply(message), service => service.UpdateMessage(message));
                            }

                            if (i >= 0 && i == Items.Count - 1 && Items[i].Content is MessageHeaderUnread)
                            {
                                toBeDeleted ??= new();
                                toBeDeleted.Add(message);
                            }
                        }

                        if (toBeDeleted != null)
                        {
                            //Delegate?.UpdateDeleteMessages(_chat, toBeDeleted);

                            foreach (var item in toBeDeleted)
                            {
                                Items.Remove(item);
                            }
                        }

                        if (Items.Count > 0 && Items[^1].Content is MessageHeaderUnread)
                        {
                            Items.RemoveAt(Items.Count - 1);
                        }
                    }

                    foreach (var id in update.MessageIds)
                    {
                        if (_composerHeader != null && _composerHeader.Matches(id))
                        {
                            ClearReply();
                            break;
                        }
                    }
                });
            }
        }



        public void Handle(UpdateMessageContent update)
        {
            if (update.ChatId == _chat?.Id)
            {
                Handle(update.MessageId, message =>
                {
                    if (update.NewContent is not MessageAlbum and not MessageStory)
                    {
                        message.Reset();
                        message.Content = update.NewContent;

                        if (IsTranslating)
                        {
                            _translateService.Translate(message, Settings.Translate.To);
                        }

                        ProcessEmoji(message);

                        if (update.NewContent is MessageExpiredPhoto or MessageExpiredVideo or MessageExpiredVideoNote or MessageExpiredVoiceNote)
                        {
                            // Probably not the best way
                            Items.Remove(message);
                            InsertMessageInOrder(Items, message);
                        }
                    }
                }, (bubble, message, reply) =>
                {
                    if (reply)
                    {
                        bubble.UpdateMessageReply(message);
                    }
                    else
                    {
                        bubble.UpdateMessageContent(message);
                        Delegate?.ViewVisibleMessages();
                    }
                });

                //BeginOnUIThread(() =>
                //{
                //    for (int i = 0; i < PinnedMessages.Count; i++)
                //    {
                //        if (PinnedMessages[i].Id == update.MessageId)
                //        {
                //            PinnedMessages[i].Content = update.NewContent;
                //            Delegate?.UpdatePinnedMessage();

                //            break;
                //        }
                //    }
                //});
            }
        }

        public void Handle(UpdateMessageContentOpened update)
        {
            if (update.ChatId == _chat?.Id)
            {
                Handle(update.MessageId, message =>
                {
                    // TODO: this makes no sense
                    if (message.SelfDestructType is MessageSelfDestructTypeTimer timer)
                    {
                        message.SelfDestructIn = timer.SelfDestructTime;
                    }

                    switch (message.Content)
                    {
                        case MessageVideoNote videoNote:
                            videoNote.IsViewed = true;
                            break;
                        case MessageVoiceNote voiceNote:
                            voiceNote.IsListened = true;
                            break;
                    }

                    return true;
                },
                (bubble, message) => bubble.UpdateMessageContentOpened(message));
            }
        }

        public void Handle(UpdateMessageMentionRead update)
        {
            if (update.ChatId == _chat?.Id)
            {
                _mentions.RemoveMessage(update.MessageId);

                Handle(update.MessageId, message =>
                {
                    message.ContainsUnreadMention = false;
                    return false;
                });

                BeginOnUIThread(() => Delegate?.UpdateChatUnreadMentionCount(_chat, update.UnreadMentionCount));
            }
        }

        public void Handle(UpdateMessageUnreadReactions update)
        {
            if (update.ChatId == _chat?.Id)
            {
                _reactions.RemoveMessage(update.MessageId);

                Handle(update.MessageId, message =>
                {
                    message.UnreadReactions = update.UnreadReactions;
                    return true;
                },
                (bubble, message) =>
                {
                    Delegate?.ViewVisibleMessages();
                });

                BeginOnUIThread(() => Delegate?.UpdateChatUnreadReactionCount(_chat, update.UnreadReactionCount));
            }
        }

        public void Handle(UpdateMessageEdited update)
        {
            if (update.ChatId == _chat?.Id)
            {
                Handle(update.MessageId, message =>
                {
                    message.EditDate = update.EditDate;
                    message.ReplyMarkup = update.ReplyMarkup;
                    return true;
                },
                (bubble, message) => bubble.UpdateMessageEdited(message));
            }
        }

        public void Handle(UpdateMessageInteractionInfo update)
        {
            if (update.ChatId == _chat?.Id)
            {
                Handle(update.MessageId, message =>
                {
                    message.InteractionInfo = update.InteractionInfo;
                    return true;
                },
                (bubble, message) => bubble.UpdateMessageInteractionInfo(message),
                (service, message) => service.UpdateMessageInteractionInfo(message));
            }
        }

        public void Handle(UpdateMessageIsPinned update)
        {
            if (update.ChatId == _chat?.Id)
            {
                if (_type == DialogType.Pinned)
                {
                    if (update.IsPinned)
                    {
                        ClientService.Send(new GetMessage(update.ChatId, update.MessageId), response =>
                        {
                            if (response is Message message)
                            {
                                Handle(new UpdateNewMessage(message));
                            }
                        });
                    }
                    else
                    {
                        Handle(new UpdateDeleteMessages(update.ChatId, new[] { update.MessageId }, true, false));
                    }
                }
                else
                {
                    _hasLoadedLastPinnedMessage = false;
                    BeginOnUIThread(() => LoadPinnedMessagesSliceAsync(update.MessageId));

                    Handle(update.MessageId, message =>
                    {
                        message.IsPinned = update.IsPinned;
                        return true;
                    },
                    (bubble, message) => bubble.UpdateMessageIsPinned(message));
                }
            }
        }

        public void Handle(UpdateMessageSendFailed update)
        {
            if (update.Message.ChatId == _chat?.Id)
            {
                Handle(update.OldMessageId, message =>
                {
                    message.Replace(update.Message);
                    return true;
                },
                (bubble, message) => bubble.UpdateMessage(message));
            }
        }

        public void Handle(UpdateMessageSendSucceeded update)
        {
            if (update.Message.ChatId == _chat?.Id && _type == DialogType.History && update.Message.SchedulingState is MessageSchedulingStateSendWhenVideoProcessed)
            {
                Handle(new UpdateDeleteMessages(update.Message.ChatId, new[] { update.OldMessageId }, true, false));
                BeginOnUIThread(() =>
                {
                    NavigationService.NavigateToChat(_chat, update.Message.Id, scheduled: true);
                    ShowToast(string.Format("**{0}**\n{1}", Strings.VideoConversionTitle, Strings.VideoConversionText), ToastPopupIcon.VideoConversion);
                });
            }
            else if (update.Message.ChatId == _chat?.Id && CheckSchedulingState(update.Message))
            {
                Handle(update.OldMessageId, message =>
                {
                    message.Replace(update.Message);
                    message.GeneratedContentUnread = true;

                    if (message.Content is MessagePaidMedia paidMedia)
                    {
                        message.Content = new MessagePaidAlbum(paidMedia);
                    }

                    return true; //MoveMessageInOrder(Items, message);
                },
                (bubble, message) =>
                {
                    bubble.UpdateMessage(message);
                    Delegate?.ViewVisibleMessages();