DialogViewModel.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.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using Telegram.Collections;
using Telegram.Common;
using Telegram.Common.Chats;
using Telegram.Controls;
using Telegram.Controls.Chats;
using Telegram.Controls.Messages;
using Telegram.Converters;
using Telegram.Navigation;
using Telegram.Navigation.Services;
using Telegram.Services;
using Telegram.Services.Factories;
using Telegram.Td;
using Telegram.Td.Api;
using Telegram.ViewModels.Chats;
using Telegram.ViewModels.Delegates;
using Telegram.Views;
using Telegram.Views.Popups;
using Telegram.Views.Premium.Popups;
using Telegram.Views.Users;
using Windows.ApplicationModel.DataTransfer;
using Windows.UI.Text;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Media.Animation;
using Windows.UI.Xaml.Navigation;
using Point = Windows.Foundation.Point;

namespace Telegram.ViewModels
{
    public partial class ChatMessageIdNavigationArgs
    {
        public ChatMessageIdNavigationArgs(long chatId, long threadId)
        {
            ChatId = chatId;
            MessageId = threadId;
        }

        public long ChatId { get; }

        public long MessageId { get; }
    }

    public partial class ChatSavedMessagesTopicIdNavigationArgs
    {
        public ChatSavedMessagesTopicIdNavigationArgs(long chatId, long savedMessagesTopicId)
        {
            ChatId = chatId;
            SavedMessagesTopicId = savedMessagesTopicId;
        }

        public long ChatId { get; }

        public long SavedMessagesTopicId { get; }
    }

    public partial class ChatBusinessRepliesIdNavigationArgs
    {
        public ChatBusinessRepliesIdNavigationArgs(string quickReplyShortcut)
        {
            QuickReplyShortcut = quickReplyShortcut;
        }

        public string QuickReplyShortcut { get; }
    }

    public partial class DialogViewModel : ComposeViewModel, IDelegable<IDialogDelegate>
    {
        private readonly ConcurrentDictionary<long, MessageViewModel> _selectedItems = new();
        public IDictionary<long, MessageViewModel> SelectedItems => _selectedItems;

        public int SelectedCount => SelectedItems.Count;

        protected readonly ConcurrentDictionary<long, MessageViewModel> _groupedMessages = new();
        protected readonly ConcurrentDictionary<long, HashSet<long>> _messageEffects = new();

        protected static readonly Dictionary<MessageId, MessageContent> _contentOverrides = new();

        protected readonly DisposableMutex _loadMoreLock = new();

        protected readonly IMessageDelegate _messageDelegate;

        protected readonly DialogUnreadMessagesViewModel _mentions;
        protected readonly DialogUnreadMessagesViewModel _reactions;

        protected readonly ILocationService _locationService;
        protected readonly INotificationsService _notificationsService;
        protected readonly IPlaybackService _playbackService;
        protected readonly IVoipService _voipService;
        protected readonly INetworkService _networkService;
        protected readonly IStorageService _storageService;
        protected readonly ITranslateService _translateService;

        public IPlaybackService PlaybackService => _playbackService;

        public IStorageService StorageService => _storageService;

        public ITranslateService TranslateService => _translateService;

        public IVoipService VoipService => _voipService;

        public DialogUnreadMessagesViewModel Mentions => _mentions;
        public DialogUnreadMessagesViewModel Reactions => _reactions;

        public IDialogDelegate Delegate { get; set; }

        public DialogViewModel(IClientService clientService, ISettingsService settingsService, IEventAggregator aggregator, ILocationService locationService, INotificationsService pushService, IPlaybackService playbackService, IVoipService voipService, INetworkService networkService, IStorageService storageService, ITranslateService translateService)
            : base(clientService, settingsService, aggregator)
        {
            _locationService = locationService;
            _notificationsService = pushService;
            _playbackService = playbackService;
            _voipService = voipService;
            _networkService = networkService;
            _storageService = storageService;
            _translateService = translateService;

            _messageDelegate = new DialogMessageDelegate(this);

            _mentions = new DialogUnreadMessagesViewModel(this, new SearchMessagesFilterUnreadMention());
            _reactions = new DialogUnreadMessagesViewModel(this, new SearchMessagesFilterUnreadReaction());

            //Items = new LegacyMessageCollection();
            //Items.CollectionChanged += (s, args) => IsEmpty = Items.Count == 0;

            _count++;
            System.Diagnostics.Debug.WriteLine("Creating DialogViewModel {0}", _count);
        }

        private static volatile int _count;

        ~DialogViewModel()
        {
            System.Diagnostics.Debug.WriteLine("Finalizing DialogViewModel {0}", _count);
            _count--;
        }

        public void Dispose()
        {
            System.Diagnostics.Debug.WriteLine("Disposing DialogViewModel");
            _groupedMessages.Clear();
        }

        public Action<Sticker> Sticker_Click;

        protected Chat _linkedChat;
        public Chat LinkedChat
        {
            get => _linkedChat;
            set => Set(ref _linkedChat, value);
        }

        public override long ThreadId
        {
            get
            {
                if (_topic != null)
                {
                    return _topic.Info.MessageThreadId;
                }
                else if (_thread != null)
                {
                    return _thread.MessageThreadId;
                }

                return 0;
            }
        }

        public override long OutgoingThreadId
        {
            get
            {
                if (_topic != null)
                {
                    return _topic.Info.IsGeneral ? 0 : _topic.Info.MessageThreadId;
                }
                else if (_thread != null)
                {
                    return _thread.MessageThreadId;
                }

                return 0;
            }
        }

        protected MessageThreadInfo _thread;
        public MessageThreadInfo Thread
        {
            get => _thread;
            set => Set(ref _thread, value);
        }

        protected ForumTopic _topic;
        public ForumTopic Topic
        {
            get => _topic;
            set => Set(ref _topic, value);
        }

        protected SavedMessagesTopic _savedMessagesTopic;
        public SavedMessagesTopic SavedMessagesTopic
        {
            get => _savedMessagesTopic;
            set => Set(ref _savedMessagesTopic, value);
        }

        protected QuickReplyShortcut _quickReplyShortcut;
        public QuickReplyShortcut QuickReplyShortcut
        {
            get => _quickReplyShortcut;
            set => Set(ref _quickReplyShortcut, value);
        }

        public long SavedMessagesTopicId => SavedMessagesTopic?.Id ?? 0;

        protected Chat _chat;
        public override Chat Chat
        {
            get => _chat;
            set => Set(ref _chat, value);
        }

        private DialogType _type => Type;
        public virtual DialogType Type => DialogType.History;

        private DispatcherTimer _lastSeenTimer;

        private string _lastSeen;
        public string LastSeen
        {
            get => _type switch
            {
                DialogType.EventLog => Strings.EventLog,
                DialogType.SavedMessagesTopic => Strings.SavedMessagesTab,
                _ => _lastSeen
            };
            set
            {
                Set(ref _lastSeen, value);
                RaisePropertyChanged(nameof(Subtitle));
            }
        }

        public void UpdateLastSeen(string value)
        {
            _lastSeenTimer?.Stop();
            LastSeen = value;
        }

        public void UpdateLastSeen(User user)
        {
            var interval = LastSeenConverter.OnlinePhraseChange(user.Status, DateTime.Now);
            if (interval > 0 && _lastSeenTimer == null)
            {
                _lastSeenTimer ??= new DispatcherTimer();
                _lastSeenTimer.Tick += LastSeenTimer_Tick;
            }

            _lastSeenTimer?.Stop();

            if (interval > 0)
            {
                _lastSeenTimer.Interval = TimeSpan.FromSeconds(interval);
                _lastSeenTimer.Start();
            }

            LastSeen = LastSeenConverter.GetLabel(user, true, true);
        }

        private void LastSeenTimer_Tick(object sender, object e)
        {
            if (ClientService.TryGetUser(Chat, out User user))
            {
                UpdateLastSeen(user);
            }
        }

        private string _onlineCount;
        public string OnlineCount
        {
            get => _onlineCount;
            set
            {
                Set(ref _onlineCount, value);
                RaisePropertyChanged(nameof(Subtitle));
            }
        }

        public virtual string Subtitle
        {
            get
            {
                var chat = _chat;
                if (chat == null)
                {
                    return null;
                }

                if (chat.Type is ChatTypePrivate or ChatTypeSecret)
                {
                    return LastSeen;
                }

                if (Topic == null && !string.IsNullOrEmpty(OnlineCount) && !string.IsNullOrEmpty(LastSeen))
                {
                    return string.Format("{0}, {1}", LastSeen, OnlineCount);
                }

                return LastSeen;
            }
        }

        private ChatSearchViewModel _search;
        public ChatSearchViewModel Search
        {
            get => _search;
            set => Set(ref _search, value);
        }

        public void DisposeSearch()
        {
            var search = _search;
            if (search != null)
            {
                search.Dispose();
                UpdateQuery(string.Empty);
            }

            Search = null;
        }

        private string _accessToken;
        public string AccessToken
        {
            get => _accessToken;
            set
            {
                Set(ref _accessToken, value);
                RaisePropertyChanged(nameof(HasAccessToken));
            }
        }

        public bool HasAccessToken
        {
            get
            {
                return (_accessToken != null || _isEmpty) && !_loadingSlice;
            }
        }

        private bool _restrictsNewChats;
        public bool RestrictsNewChats
        {
            get => _restrictsNewChats;
            set => Set(ref _restrictsNewChats, value);
        }

        private DispatcherTimer _informativeTimer;

        private MessageViewModel _informativeMessage;
        public MessageViewModel InformativeMessage
        {
            get => _informativeMessage;
            set
            {
                _informativeTimer?.Stop();

                if (value != null)
                {
                    if (_informativeTimer == null)
                    {
                        _informativeTimer = new DispatcherTimer();
                        _informativeTimer.Interval = TimeSpan.FromSeconds(5);
                        _informativeTimer.Tick += (s, args) =>
                        {
                            _informativeTimer.Stop();
                            InformativeMessage = null;
                        };
                    }

                    _informativeTimer.Start();
                }

                Set(ref _informativeMessage, value);
                Delegate?.UpdateCallbackQueryAnswer(_chat, value);
            }
        }

        private OutputChatActionManager _chatActionManager;
        public OutputChatActionManager ChatActionManager
        {
            get
            {
                return _chatActionManager ??= new OutputChatActionManager(ClientService, _chat, OutgoingThreadId);
            }
        }

        private bool _needsUpdateSpeechRecognitionTrial;

        private bool _hasLoadedLastPinnedMessage = false;

        public long LockedPinnedMessageId { get; set; }
        public MessageViewModel LastPinnedMessage { get; private set; }
        public IList<MessageViewModel> PinnedMessages { get; } = new List<MessageViewModel>();

        private Td.Api.Chats _groupsInCommon;
        public Td.Api.Chats GroupsInCommon
        {
            get => _groupsInCommon;
            set => Set(ref _groupsInCommon, value);
        }

        private SponsoredMessage _sponsoredMessage;
        public SponsoredMessage SponsoredMessage
        {
            get => _sponsoredMessage;
            set => Set(ref _sponsoredMessage, value);
        }

        private SavedMessagesTags _savedMessagesTags;
        public SavedMessagesTags SavedMessagesTags
        {
            get => _savedMessagesTags;
            set => Set(ref _savedMessagesTags, value);
        }

        public void UpdateSavedMessagesTag(ReactionType tag, bool filterByTag, ReactionType lastTag)
        {
            bool TryGetLastVisibleMessageIdAndPixel(out long lastVisibleId, out double? lastVisiblePixel)
            {
                lastVisibleId = 0;
                lastVisiblePixel = null;

                var field = HistoryField;
                if (field != null && !field.IsSuspended && TryGetLastVisibleMessageId(out lastVisibleId, out int lastVisibleIndex))
                {
                    if (lastVisibleId != 0)
                    {
                        var message = Items[lastVisibleIndex];
                        if (message.InteractionInfo?.Reactions != null && message.InteractionInfo.Reactions.IsChosen(lastTag))
                        {
                            var container = field.ContainerFromIndex(lastVisibleIndex) as SelectorItem;
                            if (container != null)
                            {
                                var transform = container.TransformToVisual(field);
                                var position = transform.TransformPoint(new Point());

                                lastVisiblePixel = field.ActualHeight - (position.Y + container.ActualHeight);
                            }

                            return true;
                        }
                    }
                }

                return false;
            }

            if (lastTag != null && TryGetLastVisibleMessageIdAndPixel(out long lastVisibleId, out double? lastVisiblePixel))
            {
                _ = LoadMessageSliceAsync(null, lastVisibleId, VerticalAlignment.Bottom, lastVisiblePixel, onlyRemote: true);
            }
            else
            {
                _ = LoadMessageSliceAsync(null, long.MaxValue, VerticalAlignment.Bottom, onlyRemote: true);
            }

            if (_chat is Chat chat && chat.Type is ChatTypePrivate privata)
            {
                var item = ClientService.GetUser(privata.UserId);
                var cache = ClientService.GetUserFull(privata.UserId);

                if (cache != null)
                {
                    Delegate?.UpdateUserFullInfo(chat, item, cache, false, false);
                }
                else
                {
                    ClientService.Send(new GetUserFullInfo(privata.UserId));
                }
            }

            if (filterByTag is false && tag != null)
            {
                Search?.Search(Search.Query, null, null, tag);
            }
        }

        public int UnreadCount
        {
            get
            {
                if (_type != DialogType.History)
                {
                    return 0;
                }

                return _chat?.UnreadCount ?? 0;
            }
        }

        private bool _isSelectionEnabled;
        public bool IsSelectionEnabled
        {
            get => _isSelectionEnabled;
            set => ShowHideSelection(value);
        }

        public void ShowHideSelection(bool value, ReportChatSelection report = null)
        {
            if (_isSelectionEnabled != value)
            {
                Set(ref _isReportingMessages, report, nameof(IsReportingMessages));
                Set(ref _isSelectionEnabled, value, nameof(IsSelectionEnabled));

                if (value)
                {
                    DisposeSearch();
                }
                else
                {
                    SelectedItems.Clear();
                }
            }
        }

        public ChatTextBox TextField { get; set; }
        public ChatHistoryView HistoryField { get; set; }

        public void SetSelection(int start)
        {
            var field = TextField;
            if (field == null)
            {
                return;
            }

            field.Document.GetText(TextGetOptions.None, out string text);
            field.Document.Selection.SetRange(start, text.Length);
        }

        public void SetText(FormattedText text, bool focus = false)
        {
            if (text == null)
            {
                SetText(null, null, focus);
            }
            else
            {
                SetText(text.Text, text.Entities, focus);
            }
        }

        public void SetText(string text, IList<TextEntity> entities = null, bool focus = false)
        {
            var field = TextField;
            if (field == null)
            {
                return;
            }

            var chat = Chat;
            if (chat != null && chat.Type is ChatTypeSupergroup super && super.IsChannel && !string.IsNullOrEmpty(text))
            {
                var supergroup = ClientService.GetSupergroup(super.SupergroupId);
                if (supergroup != null && !supergroup.CanPostMessages())
                {
                    return;
                }
            }

            if (string.IsNullOrEmpty(text))
            {
                field.SetText(null);
            }
            else
            {
                field.SetText(text, entities);
            }

            if (focus)
            {
                field.Focus(FocusState.Keyboard);
            }
        }

        public void SetScrollMode(ItemsUpdatingScrollMode mode, bool force)
        {
            var field = HistoryField;
            if (field == null)
            {
                return;
            }

            field.SetScrollingMode(mode, force);
        }

        public override FormattedText GetFormattedText(bool clear = false, bool parseMarkdown = true)
        {
            var field = TextField;
            if (field == null)
            {
                return new FormattedText(string.Empty, Array.Empty<TextEntity>());
            }

            return field.GetFormattedText(clear, parseMarkdown);
        }

        public bool IsEndReached()
        {
            var lastMessage = _savedMessagesTopic?.LastMessage ?? _chat?.LastMessage;
            if (lastMessage == null)
            {
                return Items.Empty();
            }

            var last = Items.LastOrDefault();
            if (last?.Content is MessageAlbum album)
            {
                last = album.Messages.LastOrDefault();
            }

            if (last == null || last.Id == 0)
            {
                return true;
            }

            return lastMessage.Id == last.Id;
        }

        private bool _isChatEmpty;

        private Sticker _greetingSticker;
        public Sticker GreetingSticker
        {
            get => _greetingSticker;
            set => Set(ref _greetingSticker, value);
        }

        private bool? _isFirstSliceLoaded;
        public bool? IsFirstSliceLoaded
        {
            get => _isFirstSliceLoaded;
            set => Set(ref _isFirstSliceLoaded, value);
        }

        public bool? IsLastSliceLoaded { get; set; }

        private bool _isEmpty = true;
        public bool IsEmpty
        {
            get => _isEmpty && !_loadingSlice;
            set
            {
                Set(ref _isEmpty, value);
                RaisePropertyChanged(nameof(HasAccessToken));
            }
        }

        public override bool IsLoading
        {
            get => _loadingSlice;
            set
            {
                base.IsLoading = value;
                RaisePropertyChanged(nameof(IsEmpty));
                RaisePropertyChanged(nameof(HasAccessToken));
            }
        }

        protected bool _loadingSlice;

        protected Stack<long> _repliesStack = new Stack<long>();

        public Stack<long> RepliesStack => _repliesStack;

        // Scrolling to top
        public virtual Task LoadNextSliceAsync()
        {
            return LoadNextSliceAsync(PanelScrollingDirection.Backward);
        }

        // Scrolling to bottom
        public Task LoadPreviousSliceAsync()
        {
            return LoadNextSliceAsync(PanelScrollingDirection.Forward);
        }

        private async Task LoadNextSliceAsync(PanelScrollingDirection direction)
        {
            // Backward => Going to top, to the past
            // Forward => Going to bottom, to the present

            if (_type is not DialogType.History and not DialogType.Thread and not DialogType.Pinned and not DialogType.SavedMessagesTopic)
            {
                return;
            }

            var chat = _chat;
            if (chat == null)
            {
                return;
            }

            using (await _loadMoreLock.WaitAsync())
            {
                if (_loadingSlice || _chat?.Id != chat.Id || Items.Count < 1)
                {
                    return;
                }

                if (direction == PanelScrollingDirection.Backward && IsLastSliceLoaded == true)
                {
                    return;
                }

                _loadingSlice = true;
                IsLoading = true;

                System.Diagnostics.Debug.WriteLine("DialogViewModel: LoadNextSliceAsync");

                MessageViewModel fromMessage;
                long fromMessageId;
                int offset;

                if (direction == PanelScrollingDirection.Backward)
                {
                    fromMessage = Items.Count > 0 ? Items[0] : null;
                    fromMessageId = Items.FirstId;
                    offset = 0;
                }
                else
                {
                    fromMessage = null;
                    fromMessageId = Items.LastId;
                    offset = -49;
                }

                if (fromMessageId == long.MaxValue || fromMessageId == long.MinValue)
                {
                    _loadingSlice = false;
                    IsLoading = false;

                    return;
                }

                Function func;
                if (Search?.SavedMessagesTag != null)
                {
                    func = new SearchSavedMessages(SavedMessagesTopicId, Search.SavedMessagesTag, string.Empty, fromMessageId, offset, 50);
                }
                else if (SavedMessagesTopicId != 0)
                {
                    func = new GetSavedMessagesTopicHistory(SavedMessagesTopicId, fromMessageId, offset, 50);
                }
                else if (Topic != null)
                {
                    func = new GetMessageThreadHistory(chat.Id, _topic.Info.MessageThreadId, fromMessageId, offset, 50);
                }
                else if (Thread != null)
                {
                    func = new GetMessageThreadHistory(chat.Id, _thread.MessageThreadId, fromMessageId, offset, 50);
                }
                else if (_type == DialogType.Pinned)
                {
                    func = new SearchChatMessages(chat.Id, string.Empty, null, fromMessageId, offset, 50, new SearchMessagesFilterPinned(), 0, 0);
                }
                else
                {
                    func = new GetChatHistory(chat.Id, fromMessageId, offset, 50, false);
                }

                var tsc = new TaskCompletionSource<MessageCollection>();
                async void handler(BaseObject result)
                {
                    if (result is FoundChatMessages foundChatMessages)
                    {
                        result = await PreloadAlbumsAsync(chat.Id, foundChatMessages);
                    }

                    if (result is Messages messages)
                    {
                        var endReached = messages.MessagesValue.Empty();
                        if (endReached && direction == PanelScrollingDirection.Backward)
                        {
                            await AddHeaderAsync(messages.MessagesValue, fromMessage?.Get());
                        }

                        tsc.SetResult(new MessageCollection(Items.Ids, messages.MessagesValue, CreateMessage, endReached));
                    }
                    else
                    {
                        tsc.SetResult(null);
                    }
                }

                ClientService.Send(func, handler);

                var response = await tsc.Task;
                if (response is MessageCollection replied)
                {
                    if (replied.Count > 0)
                    {
                        ProcessMessages(chat, replied);

                        if (direction == PanelScrollingDirection.Backward)
                        {
                            SetScrollMode(ItemsUpdatingScrollMode.KeepLastItemInView, true);
                            Items.RawInsertRange(0, replied, true, out bool empty);
                        }
                        else
                        {
                            SetScrollMode(ItemsUpdatingScrollMode.KeepItemsInView, true);
                            Items.RawAddRange(replied, true, out bool empty);
                        }
                    }
                    else if (direction != PanelScrollingDirection.Backward)
                    {
                        SetScrollMode(ItemsUpdatingScrollMode.KeepLastItemInView, true);
                    }

                    if (direction == PanelScrollingDirection.Backward)
                    {
                        IsLastSliceLoaded = replied.IsEndReached;
                        UpdateDetectedLanguage();
                    }
                    else
                    {
                        IsFirstSliceLoaded = replied.IsEndReached || IsEndReached();
                    }
                }

                _loadingSlice = false;
                IsLoading = false;

                LoadPinnedMessagesSliceAsync(fromMessageId, direction);
            }
        }

        protected async Task AddHeaderAsync(IList<Message> messages, Message previous)
        {
            if (previous != null && (previous.Content is MessageHeaderDate || (previous.Content is MessageText && previous.Id == 0)))
            {
                return;
            }

            var chat = _chat;
            if (chat == null || _type != DialogType.History)
            {
                goto AddDate;
            }

            var user = ClientService.GetUser(chat);
            if (user?.Type is not UserTypeBot)
            {
                goto AddDate;
            }

            if (chat.Id == ClientService.Options.VerificationCodesBotChatId)
            {
                var entities = ClientEx.GetTextEntities(Strings.VerifyChatInfo);
                var text = new FormattedText(Strings.VerifyChatInfo, entities);

                var content = new MessageText(text, null, null);

                messages.Add(new Message(0, new MessageSenderUser(user.Id), chat.Id, null, null, false, false, false, false, false, false, false, false, 0, 0, null, null, null, null, null, null, 0, 0, null, 0, 0, 0, 0, 0, 0, string.Empty, 0, 0, false, string.Empty, content, null));
                return;
            }
            else
            {
                var fullInfo = ClientService.GetUserFull(user.Id);
                fullInfo ??= await ClientService.SendAsync(new GetUserFullInfo(user.Id)) as UserFullInfo;

                if (fullInfo?.BotInfo?.Description.Length > 0)
                {
                    var entities = ClientEx.GetTextEntities(fullInfo.BotInfo.Description);

                    foreach (var entity in entities)
                    {
                        entity.Offset += Strings.BotInfoTitle.Length + Environment.NewLine.Length;
                    }

                    entities.Add(new TextEntity(0, Strings.BotInfoTitle.Length, new TextEntityTypeBold()));

                    var message = $"{Strings.BotInfoTitle}{Environment.NewLine}{fullInfo.BotInfo.Description}";
                    var text = new FormattedText(message, entities);

                    MessageContent content;
                    if (fullInfo.BotInfo.Animation != null)
                    {
                        content = new MessageAnimation(fullInfo.BotInfo.Animation, text, false, false, false);
                    }
                    else if (fullInfo.BotInfo.Photo != null)
                    {
                        content = new MessagePhoto(fullInfo.BotInfo.Photo, text, false, false, false);
                    }
                    else
                    {
                        content = new MessageText(text, null, null);
                    }

                    messages.Add(new Message(0, new MessageSenderUser(user.Id), chat.Id, null, null, false, false, false, false, false, false, false, false, 0, 0, null, null, null, null, null, null, 0, 0, null, 0, 0, 0, 0, 0, 0, string.Empty, 0, 0, false, string.Empty, content, null));
                    return;
                }
            }

        AddDate:
            if (_topic == null && _thread != null)
            {
                var replied = _thread.Messages.OrderBy(x => x.Id).ToList();
                var empty = previous == null;

                previous = replied[0];

                if (empty)
                {
                    messages.Add(new Message(0, previous.SenderId, previous.ChatId, null, null, previous.IsOutgoing, false, false, false, false, previous.IsChannelPost, previous.IsTopicMessage, false, previous.Date, 0, null, null, null, null, null, null, 0, 0, null, 0, 0, 0, 0, 0, 0, string.Empty, 0, 0, false, string.Empty, new MessageCustomServiceAction(Strings.NoComments), null));
                }
                else
                {
                    messages.Add(new Message(0, previous.SenderId, previous.ChatId, null, null, previous.IsOutgoing, false, false, false, false, previous.IsChannelPost, previous.IsTopicMessage, false, previous.Date, 0, null, null, null, null, null, null, 0, 0, null, 0, 0, 0, 0, 0, 0, string.Empty, 0, 0, false, string.Empty, new MessageCustomServiceAction(Strings.DiscussionStarted), null));
                }

                for (int i = replied.Count - 1; i >= 0; i--)
                {
                    messages.Add(replied[i]);
                }
            }

            if (previous != null)
            {
                messages.Add(new Message(0, previous.SenderId, previous.ChatId, null, null, previous.IsOutgoing, false, false, false, false, previous.IsChannelPost, previous.IsTopicMessage, false, previous.Date, 0, null, null, null, null, null, null, 0, 0, null, 0, 0, 0, 0, 0, 0, string.Empty, 0, 0, false, string.Empty, new MessageHeaderDate(), null));
            }
        }

        public async void PreviousSlice()
        {
            if (_type is DialogType.ScheduledMessages or DialogType.EventLog)
            {
                ScrollToBottom();
            }
            else if (_repliesStack.Count > 0)
            {
                await LoadMessageSliceAsync(null, _repliesStack.Pop());
            }
            else
            {
                await LoadLastSliceAsync();
            }

            TextField?.Focus(FocusState.Programmatic);
        }

        public Task LoadLastSliceAsync()
        {
            var chat = _chat;
            if (chat == null)
            {
                return Task.CompletedTask;
            }

            long lastReadMessageId;
            long lastMessageId;

            if (_savedMessagesTopic is SavedMessagesTopic savedMessagesTopic)
            {
                lastReadMessageId = savedMessagesTopic.LastMessage?.Id ?? long.MaxValue;
                lastMessageId = savedMessagesTopic.LastMessage?.Id ?? long.MaxValue;
            }
            else if (_topic is ForumTopic topic)
            {
                lastReadMessageId = topic.LastReadInboxMessageId;
                lastMessageId = topic.LastMessage?.Id ?? long.MaxValue;
            }
            else if (_thread is MessageThreadInfo thread)
            {
                lastReadMessageId = thread.ReplyInfo?.LastReadInboxMessageId ?? long.MaxValue;
                lastMessageId = thread.ReplyInfo?.LastMessageId ?? long.MaxValue;
            }
            else
            {
                lastReadMessageId = chat.LastReadInboxMessageId;
                lastMessageId = chat.LastMessage?.Id ?? long.MaxValue;
            }

            if (TryGetLastVisibleMessageId(out long lastVisibleId, out int lastVisibleIndex))
            {