using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Linq;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Messaging;
using CommunityToolkit.Mvvm.Messaging.Messages;
using Wino.Core.Domain.Entities.Mail;
using Wino.Mail.ViewModels.Data;

namespace Wino.Mail.ViewModels.Collections;

/// <summary>
/// Grouping options for emails
/// </summary>
public enum EmailGroupingType
{
    ByFromName,
    ByDate
}

/// <summary>
/// Sorting options for emails within groups
/// </summary>
public enum EmailSortDirection
{
    Ascending,
    Descending
}

/// <summary>
/// Collection that automatically groups MailItemViewModels with ThreadMailItemViewModels in a flat structure for ItemsView.
/// All emails are in the same flat list with proper selection support. Thread emails are placed consecutively after their expander.
/// </summary>
public partial class GroupedEmailCollection : ObservableObject, IRecipient<PropertyChangedMessage<bool>>, IDisposable
{
    public event EventHandler SelectionChanged;

    private readonly ObservableCollection<MailItemViewModel> _sourceItems = [];
    private readonly Dictionary<string, GroupHeaderBase> _groupHeaders = [];
    private readonly Dictionary<string, int> _groupHeaderIndexCache = [];
    private readonly Dictionary<string, List<object>> _groupItems = [];
    private readonly Dictionary<string, ThreadMailItemViewModel> _threadExpanders = [];
    private readonly HashSet<Guid> _mailCopyIdHashSet = [];
    private readonly HashSet<MailItemViewModel> _selectedVisibleItems = [];
    private bool _disposed;
    private bool _isUpdating;

    [ObservableProperty]
    private EmailGroupingType groupingType = EmailGroupingType.ByDate;

    [ObservableProperty]
    private EmailSortDirection sortDirection = EmailSortDirection.Descending;

    // Tracks the number of currently selected visible mail items. Notify derived bools when changed.
    [ObservableProperty]
    [NotifyPropertyChangedFor(nameof(HasSelectedItems))]
    [NotifyPropertyChangedFor(nameof(HasSingleItemSelected))]
    [NotifyPropertyChangedFor(nameof(HasMultipleItemsSelected))]
    [NotifyPropertyChangedFor(nameof(IsAllItemsSelected))]
    public partial int SelectedVisibleCount { get; set; }

    /// <summary>
    /// Indicates whether there are any selected visible items.
    /// </summary>
    public bool HasSelectedItems => SelectedVisibleCount > 0;

    /// <summary>
    /// Indicates whether there is exactly one selected visible item.
    /// </summary>
    public bool HasSingleItemSelected => SelectedVisibleCount == 1;

    /// <summary>
    /// Indicates whether there are multiple selected visible items.
    /// </summary>
    public bool HasMultipleItemsSelected => SelectedVisibleCount > 1;

    /// <summary>
    /// Indicates whether all mail items are currently selected.
    /// Counts all mail items including those in threads, regardless of thread expansion state.
    /// </summary>
    public bool IsAllItemsSelected
    {
        get
        {
            var totalMailItems = _sourceItems.Count;
            if (totalMailItems == 0) return false;

            var selectedCount = 0;

            // Count selected standalone emails (not in threads)
            selectedCount += _sourceItems.Count(e => e.IsSelected && !e.IsDisplayedInThread);

            // Count selected emails in threads
            foreach (var expander in _threadExpanders.Values)
            {
                if (expander.IsSelected)
                {
                    // If thread is selected, all emails in the thread are considered selected
                    selectedCount += expander.ThreadEmails.Count;
                }
                else
                {
                    // If thread is not selected, count only individually selected emails within the thread
                    selectedCount += expander.ThreadEmails.Count(e => e.IsSelected);
                }
            }

            return selectedCount == totalMailItems;
        }
    }

    public GroupedEmailCollection()
    {
        // Create a flat collection for ItemsView with headers, expanders and emails mixed
        Items = [];

        // Subscribe to source collection changes to update grouping
        _sourceItems.CollectionChanged += OnSourceItemsChanged;

        // Register for PropertyChanged messages
        WeakReferenceMessenger.Default.Register<PropertyChangedMessage<bool>>(this);

        RefreshGrouping();
    }

    /// <summary>
    /// Flat observable collection containing group headers, thread expanders, and email items for ItemsView binding.
    /// Structure: GroupHeader -> [ThreadExpander -> ThreadEmail1, ThreadEmail2, ...] -> StandaloneEmail1 -> StandaloneEmail2
    /// </summary>
    public ObservableCollection<object> Items { get; }

    /// <summary>
    /// Total number of emails across all groups
    /// </summary>
    public int TotalCount => _sourceItems.Count;

    /// <summary>
    /// Total number of unread emails across all groups
    /// </summary>
    public int TotalUnreadCount => _sourceItems.Count(e => e.MailCopy?.IsRead == false);

    /// <summary>
    /// HashSet containing unique IDs of all mail copies in the collection for pagination tracking
    /// </summary>
    public HashSet<Guid> MailCopyIdHashSet => _mailCopyIdHashSet;

    /// <summary>
    /// Gets all email items across all groups as a flat collection
    /// </summary>
    public IEnumerable<MailItemViewModel> AllItems => _sourceItems;

    /// <summary>
    /// Gets all currently selected visible email items in the UI.
    /// This collection is automatically maintained by tracking PropertyChanged events.
    /// </summary>
    public IReadOnlyCollection<MailItemViewModel> SelectedVisibleItems => _selectedVisibleItems;

    /// <summary>
    /// Gets all currently selected email items.
    /// Includes:
    /// - Standalone mail items where IsSelected=true
    /// - Mail items inside threads where the mail item's IsSelected=true (regardless of thread expansion)
    /// - All mail items inside a thread where the thread's IsSelected=true
    /// </summary>
    public IEnumerable<MailItemViewModel> SelectedItems
    {
        get
        {
            var selectedItems = new List<MailItemViewModel>();

            // Add selected standalone emails (not in threads)
            selectedItems.AddRange(_sourceItems.Where(e => e.IsSelected && !e.IsDisplayedInThread));

            // Process thread expanders
            foreach (var expander in _threadExpanders.Values)
            {
                if (expander.IsSelected)
                {
                    // If thread is selected, add all emails in the thread
                    selectedItems.AddRange(expander.ThreadEmails);
                }
                else
                {
                    // If thread is not selected, add only individually selected emails within the thread
                    selectedItems.AddRange(expander.ThreadEmails.Where(e => e.IsSelected));
                }
            }

            return selectedItems;
        }
    }

    /// <summary>
    /// Gets the count of all currently selected email items.
    /// Counts:
    /// - Standalone mail items where IsSelected=true
    /// - Mail items inside threads where the mail item's IsSelected=true (regardless of thread expansion)
    /// - All mail items inside a thread where the thread's IsSelected=true
    /// </summary>
    public int SelectedItemsCount => SelectedItems.Count();

    /// <summary>
    /// Gets the number of visible email items (excluding group headers).
    /// For threads, counts the expander as 1 if collapsed, or all thread emails if expanded.
    /// </summary>
    public int Count
    {
        get
        {
            int count = 0;

            foreach (var item in Items)
            {
                switch (item)
                {
                    case GroupHeaderBase:
                        // Skip group headers
                        break;
                    case ThreadMailItemViewModel thread:
                        count += thread.ThreadEmails.Count;
                        break;
                    case MailItemViewModel:
                        count += 1;
                        break;
                }
            }
            return count;
        }
    }

    /// <summary>
    /// Handles PropertyChanged messages for thread expansion and mail item selection
    /// </summary>
    public void Receive(PropertyChangedMessage<bool> message)
    {
        // Only handle IsThreadExpanded property changes from ThreadMailItemViewModel
        if (_isUpdating)
            return;

        if (message.PropertyName == nameof(ThreadMailItemViewModel.IsThreadExpanded) && message.Sender is ThreadMailItemViewModel expander)
        {
            HandleThreadExpansion(expander);
        }
        else if (message.PropertyName == nameof(MailItemViewModel.IsSelected) && message.Sender is MailItemViewModel mailItem)
        {
            HandleMailItemSelectionChanged(mailItem, message.NewValue);
        }
        else if (message.PropertyName == nameof(ThreadMailItemViewModel.IsSelected) && message.Sender is ThreadMailItemViewModel threadExpander)
        {
            HandleThreadSelectionChanged(threadExpander, message.NewValue);
        }
    }

    private void HandleMailItemSelectionChanged(MailItemViewModel mailItem, bool isSelected)
    {
        bool selectionChanged = false;

        if (isSelected)
        {
            // Add to selected items if it's visible in the UI
            if (Items.Contains(mailItem))
            {
                if (_selectedVisibleItems.Add(mailItem))
                {
                    SelectedVisibleCount = _selectedVisibleItems.Count;
                    OnPropertyChanged(nameof(SelectedVisibleItems));
                    selectionChanged = true;
                }
            }
        }
        else
        {
            // Remove from selected items
            if (_selectedVisibleItems.Remove(mailItem))
            {
                SelectedVisibleCount = _selectedVisibleItems.Count;
                OnPropertyChanged(nameof(SelectedVisibleItems));
                selectionChanged = true;
            }
        }

        if (selectionChanged)
        {
            SelectionChanged?.Invoke(this, EventArgs.Empty);
        }
    }

    private void HandleThreadSelectionChanged(ThreadMailItemViewModel threadExpander, bool isSelected)
    {
        // When a thread expander's selection changes, it affects the selection state of all emails in that thread
        // We need to notify that the "all items selected" state might have changed
        OnPropertyChanged(nameof(IsAllItemsSelected));
        SelectionChanged?.Invoke(this, EventArgs.Empty);
    }

    /// <summary>
    /// Registers a mail item to track its selection state when added to the visible UI
    /// </summary>
    private void RegisterMailItemForSelectionTracking(MailItemViewModel mailItem)
    {
        if (mailItem == null)
            return;

        // Subscribe to property changed to track IsSelected changes
        mailItem.PropertyChanged += MailItem_PropertyChanged;

        // If the item is already selected, add it to the tracking set
        if (mailItem.IsSelected && Items.Contains(mailItem))
        {
            if (_selectedVisibleItems.Add(mailItem))
            {
                SelectedVisibleCount = _selectedVisibleItems.Count;
                SelectionChanged?.Invoke(this, EventArgs.Empty);
            }
        }
    }

    /// <summary>
    /// Unregisters a mail item from selection tracking when removed from the visible UI
    /// </summary>
    private void UnregisterMailItemFromSelectionTracking(MailItemViewModel mailItem)
    {
        if (mailItem == null)
            return;

        // Unsubscribe from property changed
        mailItem.PropertyChanged -= MailItem_PropertyChanged;

        // Remove from selected items tracking
        if (_selectedVisibleItems.Remove(mailItem))
        {
            SelectedVisibleCount = _selectedVisibleItems.Count;
            OnPropertyChanged(nameof(SelectedVisibleItems));
            SelectionChanged?.Invoke(this, EventArgs.Empty);
        }
    }

    private void MailItem_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
    {
        if (sender is MailItemViewModel mailItem && e.PropertyName == nameof(MailItemViewModel.IsSelected))
        {
            HandleMailItemSelectionChanged(mailItem, mailItem.IsSelected);
        }
    }

    private void HandleThreadExpansion(ThreadMailItemViewModel expander)
    {
        _isUpdating = true;
        try
        {
            var expanderIndex = Items.IndexOf(expander);
            if (expanderIndex == -1)
                return;

            if (expander.IsThreadExpanded)
            {
                // Add thread emails after the expander
                var insertIndex = expanderIndex + 1;
                var sortedThreadEmails = SortDirection == EmailSortDirection.Descending
                    ? expander.ThreadEmails.OrderByDescending(e => e.MailCopy.CreationDate).ToList()
                    : expander.ThreadEmails.OrderBy(e => e.MailCopy?.CreationDate).ToList();

                foreach (var email in sortedThreadEmails)
                {
                    Items.Insert(insertIndex, email);
                    RegisterMailItemForSelectionTracking(email);
                    insertIndex++;
                }

                UpdateHeaderIndicesAfterInsertion(expanderIndex + 1, expander.EmailCount);
            }
            else
            {
                // Remove thread emails from UI
                foreach (var email in expander.ThreadEmails.ToList())
                {
                    var emailIndex = Items.IndexOf(email);
                    if (emailIndex >= 0)
                    {
                        UnregisterMailItemFromSelectionTracking(email);
                        Items.RemoveAt(emailIndex);
                        UpdateHeaderIndicesAfterRemoval(emailIndex);
                    }
                }
            }

            // Notify that the "all items selected" state might have changed due to visible item count change
            OnPropertyChanged(nameof(IsAllItemsSelected));
        }
        finally
        {
            _isUpdating = false;
        }
    }

    /// <summary>
    /// Adds an email to the collection which will automatically group it.
    /// If an email with the same ThreadId exists, adds it to the existing thread or creates a new thread.
    /// </summary>
    public void AddEmail(MailItemViewModel email)
    {
        if (email?.MailCopy == null)
            return;

        // Add to unique ID tracking
        _mailCopyIdHashSet.Add(email.MailCopy.UniqueId);

        _isUpdating = true;
        try
        {
            // Check if this email belongs to a thread
            if (!string.IsNullOrEmpty(email.MailCopy.ThreadId))
            {
                // Look for existing emails with the same ThreadId
                var existingThreadEmails = _sourceItems
                    .Where(e => e.MailCopy?.ThreadId == email.MailCopy.ThreadId)
                    .ToList();

                var existingExpander = _threadExpanders.GetValueOrDefault(email.MailCopy.ThreadId);

                if (existingThreadEmails.Any() || existingExpander != null)
                {
                    // Add to existing thread
                    if (existingExpander == null)
                    {
                        // Create thread expander for the first time (existing emails become part of thread)
                        existingExpander = new ThreadMailItemViewModel(email.MailCopy.ThreadId);
                        _threadExpanders[email.MailCopy.ThreadId] = existingExpander;

                        // Remove existing standalone emails from UI and add them to the thread
                        foreach (var existingEmail in existingThreadEmails)
                        {
                            RemoveEmailFromUI(existingEmail);
                            existingExpander.AddEmail(existingEmail);
                            existingEmail.IsDisplayedInThread = true;
                        }
                    }

                    // Add the new email to the thread
                    existingExpander.AddEmail(email);
                    email.IsDisplayedInThread = true;

                    // Add to source collection
                    var insertIndex = FindInsertionIndex(email);
                    _sourceItems.Insert(insertIndex, email);

                    // Add thread expander and all emails to UI in correct positions
                    RefreshThreadInUI(existingExpander);
                }
                else
                {
                    // First email with this ThreadId - treat as standalone for now
                    email.IsDisplayedInThread = false;
                    var insertIndex = FindInsertionIndex(email);
                    _sourceItems.Insert(insertIndex, email);
                    AddEmailToUI(email);
                }
            }
            else
            {
                // No ThreadId - standalone email
                email.IsDisplayedInThread = false;
                var insertIndex = FindInsertionIndex(email);
                _sourceItems.Insert(insertIndex, email);
                AddEmailToUI(email);
            }

            OnPropertyChanged(nameof(TotalCount));
            OnPropertyChanged(nameof(TotalUnreadCount));
        }
        finally
        {
            _isUpdating = false;
        }
    }

    /// <summary>
    /// Removes an email from the collection.
    /// If the email is part of a thread and removing it would leave only 1 item in the thread,
    /// the thread is converted back to a single email.
    /// </summary>
    public void RemoveEmail(MailItemViewModel email)
    {
        if (email?.MailCopy == null)
            return;

        RemoveEmailByMailCopy(email.MailCopy);
    }

    /// <summary>
    /// Removes an email from the collection based on MailCopy.
    /// The mail copy might be in a thread where it's not visible in the UI items.
    /// In that case, it will be removed from the all items source and the thread.
    /// </summary>
    public void RemoveEmailByMailCopy(MailCopy mailCopy)
    {
        if (mailCopy == null)
            return;

        // Remove from unique ID tracking
        _mailCopyIdHashSet.Remove(mailCopy.UniqueId);

        _isUpdating = true;
        try
        {
            // Find the email in the source collection
            var email = _sourceItems.FirstOrDefault(e => e.MailCopy.UniqueId == mailCopy.UniqueId);

            if (email == null)
                return; // Email not found

            var threadId = mailCopy.ThreadId;

            // Remove from source collection
            _sourceItems.Remove(email);

            if (!string.IsNullOrEmpty(threadId) && _threadExpanders.TryGetValue(threadId, out var expander))
            {
                // Remove from thread
                expander.RemoveEmail(email);
                email.IsDisplayedInThread = false;

                // Remove email from UI if it's visible (only if thread is expanded)
                RemoveEmailFromUI(email);

                // Check if thread now has only 1 email - convert back to standalone
                if (expander.EmailCount == 1)
                {
                    var remainingEmail = expander.ThreadEmails.First();

                    // Remove thread expander and remaining email from UI
                    RemoveThreadFromUI(expander);

                    // Set remaining email as no longer displayed in thread
                    remainingEmail.IsDisplayedInThread = false;

                    // Remove thread expander tracking
                    _threadExpanders.Remove(threadId);
                    expander.Dispose();

                    // Add remaining email as standalone
                    AddEmailToUI(remainingEmail);
                }
                else if (expander.EmailCount == 0)
                {
                    // Thread is empty - remove completely
                    RemoveThreadFromUI(expander);
                    _threadExpanders.Remove(threadId);
                    expander.Dispose();
                }
                else
                {
                    // Thread still has multiple emails - refresh its position
                    RefreshThreadInUI(expander);
                }
            }
            else
            {
                // Standalone email
                email.IsDisplayedInThread = false;
                RemoveEmailFromUI(email);
            }

            // Update group headers
            UpdateGroupAfterChanges();

            OnPropertyChanged(nameof(TotalCount));
            OnPropertyChanged(nameof(TotalUnreadCount));
        }
        finally
        {
            _isUpdating = false;
        }
    }

    /// <summary>
    /// Adds multiple emails to the collection efficiently using bulk operations
    /// </summary>
    public void AddEmails(IEnumerable<MailItemViewModel> emails)
    {
        var emailList = emails.Where(e => e?.MailCopy != null).ToList();
        if (!emailList.Any())
            return;

        _isUpdating = true;
        try
        {
            // Add to unique ID tracking
            foreach (var email in emailList)
            {
                _mailCopyIdHashSet.Add(email.MailCopy.UniqueId);
            }

            // For bulk loading, add to source and use incremental refresh to preserve selection
            foreach (var email in emailList)
            {
                var insertIndex = FindInsertionIndex(email);
                _sourceItems.Insert(insertIndex, email);
            }

            // Use incremental refresh instead of full refresh to preserve selection
            IncrementalRefreshGrouping(emailList);

            OnPropertyChanged(nameof(TotalCount));
            OnPropertyChanged(nameof(TotalUnreadCount));
        }
        finally
        {
            _isUpdating = false;
        }
    }

    /// <summary>
    /// Clears all emails, threads, and headers
    /// </summary>
    public void Clear()
    {
        _isUpdating = true;
        try
        {
            // Unregister all mail items from selection tracking
            foreach (var item in Items)
            {
                if (item is MailItemViewModel mailItem)
                {
                    UnregisterMailItemFromSelectionTracking(mailItem);
                }
            }

            // Clear selected items tracking
            var hadSelectedItems = _selectedVisibleItems.Count > 0;
            _selectedVisibleItems.Clear();
            SelectedVisibleCount = 0;

            // Reset IsDisplayedInThread for all emails before clearing
            foreach (var email in _sourceItems)
            {
                email.IsDisplayedInThread = false;
            }

            // Dispose all thread expanders
            foreach (var expander in _threadExpanders.Values)
            {
                expander.Dispose();
            }

            _sourceItems.Clear();
            Items.Clear();
            _groupHeaders.Clear();
            _groupHeaderIndexCache.Clear();
            _groupItems.Clear();
            _threadExpanders.Clear();
            _mailCopyIdHashSet.Clear();

            OnPropertyChanged(nameof(TotalCount));
            OnPropertyChanged(nameof(TotalUnreadCount));
            OnPropertyChanged(nameof(SelectedVisibleItems));
            OnPropertyChanged(nameof(IsAllItemsSelected));

            if (hadSelectedItems)
            {
                SelectionChanged?.Invoke(this, EventArgs.Empty);
            }
        }
        finally
        {
            _isUpdating = false;
        }
    }

    /// <summary>
    /// Changes the grouping type and rebuilds the collection
    /// </summary>
    public void ChangeGrouping(EmailGroupingType newGroupingType, EmailSortDirection newSortDirection = EmailSortDirection.Descending)
    {
        if (GroupingType == newGroupingType && SortDirection == newSortDirection)
            return;

        GroupingType = newGroupingType;
        SortDirection = newSortDirection;
        RefreshGrouping();
    }

    /// <summary>
    /// Manually refreshes the grouping (useful after bulk operations)
    /// </summary>
    public void RefreshGrouping()
    {
        _isUpdating = true;
        try
        {
            // Unregister all mail items before clearing
            foreach (var item in Items)
            {
                if (item is MailItemViewModel mailItem)
                {
                    UnregisterMailItemFromSelectionTracking(mailItem);
                }
            }

            // Clear UI items but preserve source and expanders
            Items.Clear();
            _groupHeaders.Clear();
            _groupHeaderIndexCache.Clear();
            _groupItems.Clear();
            var hadSelectedItems = _selectedVisibleItems.Count > 0;
            _selectedVisibleItems.Clear();
            SelectedVisibleCount = 0;

            if (!_sourceItems.Any())
            {
                if (hadSelectedItems)
                {
                    SelectionChanged?.Invoke(this, EventArgs.Empty);
                }
                return;
            }

            // Rebuild thread expanders based on current emails
            RebuildThreadExpanders();

            // Group all items (standalone emails and thread expanders) by criteria
            var allItems = new List<object>();

            // Add standalone emails (emails without threads or not in any expander)
            var standaloneEmails = _sourceItems
                .Where(e => string.IsNullOrEmpty(e.MailCopy?.ThreadId) ||
                           !_threadExpanders.ContainsKey(e.MailCopy.ThreadId))
                .ToList();

            allItems.AddRange(standaloneEmails.Cast<object>());
            allItems.AddRange(_threadExpanders.Values.Cast<object>());

            // Group by criteria
            var groupedItems = allItems
                .GroupBy(item => GetGroupKeyForItem(item))
                .OrderBy(g => g.Key, GetGroupComparer());

            var currentIndex = 0;

            // Process each group
            foreach (var group in groupedItems)
            {
                // Create group header
                var groupHeader = CreateGroupHeader(group.Key);
                _groupHeaders[group.Key] = groupHeader;
                _groupHeaderIndexCache[group.Key] = currentIndex;

                // Sort items within the group
                var sortedGroupItems = SortDirection == EmailSortDirection.Descending
                    ? group.OrderByDescending(GetEffectiveDate).ToList()
                    : group.OrderBy(GetEffectiveDate).ToList();

                _groupItems[group.Key] = sortedGroupItems;

                // Add header to flat collection
                Items.Add(groupHeader);
                currentIndex++;

                // Add all items in this group to flat collection
                foreach (var item in sortedGroupItems)
                {
                    if (item is ThreadMailItemViewModel expander)
                    {
                        // Add expander
                        Items.Add(expander);
                        currentIndex++;

                        // Only add thread emails if the thread is expanded
                        if (expander.IsThreadExpanded)
                        {
                            var sortedThreadEmails = SortDirection == EmailSortDirection.Descending
                                ? expander.ThreadEmails.OrderByDescending(e => e.MailCopy?.CreationDate).ToList()
                                : expander.ThreadEmails.OrderBy(e => e.MailCopy?.CreationDate).ToList();

                            foreach (var threadEmail in sortedThreadEmails)
                            {
                                Items.Add(threadEmail);
                                RegisterMailItemForSelectionTracking(threadEmail);
                                currentIndex++;
                            }
                        }
                    }
                    else if (item is MailItemViewModel email)
                    {
                        // Add standalone email
                        Items.Add(email);
                        RegisterMailItemForSelectionTracking(email);
                        currentIndex++;
                    }
                }
            }

            // Update group header counts
            UpdateAllGroupHeaderCounts();

            // Notify that the "all items selected" state might have changed due to visible items rebuild
            OnPropertyChanged(nameof(IsAllItemsSelected));

            if (hadSelectedItems)
            {
                SelectionChanged?.Invoke(this, EventArgs.Empty);
            }
        }
        finally
        {
            _isUpdating = false;
        }
    }

    /// <summary>
    /// Incrementally adds new emails to the collection without clearing existing items
    /// </summary>
    private void IncrementalRefreshGrouping(IList<MailItemViewModel> newEmails)
    {
        _isUpdating = true;
        try
        {
            if (!newEmails.Any())
                return;

            // Update thread expanders with any new emails that should be threaded
            UpdateThreadExpandersForNewEmails(newEmails);

            // Process each new email
            foreach (var email in newEmails)
            {
                // Skip if it's already displayed in a thread
                if (email.IsDisplayedInThread)
                    continue;

                // Determine the group key for this email
                var groupKey = GetGroupKeyForItem(email);

                // Get or create the group header
                var groupHeader = GetOrCreateGroupHeader(groupKey);

                // Find where this email should be inserted in the UI
                var insertPosition = FindUIInsertionPosition(email, groupKey);

                // Insert the email at the correct position
                Items.Insert(insertPosition, email);
                RegisterMailItemForSelectionTracking(email);

                // Update the group items list
                if (!_groupItems.ContainsKey(groupKey))
                {
                    _groupItems[groupKey] = new List<object>();
                }

                // Insert in the group items list maintaining sort order
                var groupItems = _groupItems[groupKey];
                var groupInsertIndex = FindGroupInsertionIndex(email, groupItems);
                groupItems.Insert(groupInsertIndex, email);

                // If this is the first item in a new group, we need to add the header
                if (groupItems.Count == 1)
                {
                    // Find where to insert the header
                    var headerInsertPosition = FindHeaderInsertionPosition(groupKey, groupHeader);
                    Items.Insert(headerInsertPosition, groupHeader);
                    _groupHeaderIndexCache[groupKey] = headerInsertPosition;

                    // Update all subsequent header indices
                    UpdateSubsequentHeaderIndices(groupKey, 1);
                }
            }

            // Update group header counts for affected groups
            UpdateGroupHeaderCountsForNewEmails(newEmails);
        }
        finally
        {
            _isUpdating = false;
        }
    }

    /// <summary>
    /// Rebuilds thread expanders based on current source emails
    /// </summary>
    private void RebuildThreadExpanders()
    {
        // Group emails by ThreadId
        var threadGroups = _sourceItems
            .Where(e => !string.IsNullOrEmpty(e.MailCopy?.ThreadId))
            .GroupBy(e => e.MailCopy!.ThreadId!)
            .Where(g => g.Count() >= 2) // Only create threads with 2+ emails
            .ToList();

        // Remove expanders for threads that no longer have 2+ emails
        var expandersToRemove = _threadExpanders.Keys
            .Where(threadId => !threadGroups.Any(g => g.Key == threadId))
            .ToList();

        foreach (var threadId in expandersToRemove)
        {
            // Set emails back to not displayed in thread before removing expander
            foreach (var email in _threadExpanders[threadId].ThreadEmails)
            {
                email.IsDisplayedInThread = false;
            }

            _threadExpanders[threadId].Dispose();
            _threadExpanders.Remove(threadId);
        }

        // Create or update expanders for threads with 2+ emails
        foreach (var threadGroup in threadGroups)
        {
            if (!_threadExpanders.TryGetValue(threadGroup.Key, out var threadExpander))
            {
                threadExpander = new ThreadMailItemViewModel(threadGroup.Key);
                _threadExpanders[threadGroup.Key] = threadExpander;
            }

            // Clear and re-add emails to ensure consistency
            var currentEmails = threadExpander.ThreadEmails.ToList();
            foreach (var email in currentEmails)
            {
                threadExpander.RemoveEmail(email);
                email.IsDisplayedInThread = false;
            }

            foreach (var email in threadGroup)
            {
                threadExpander.AddEmail(email);
                email.IsDisplayedInThread = true;
            }
        }

        // Set standalone emails to not displayed in thread
        var standaloneEmails = _sourceItems
            .Where(e => string.IsNullOrEmpty(e.MailCopy?.ThreadId) ||
                       !_threadExpanders.ContainsKey(e.MailCopy.ThreadId))
            .ToList();

        foreach (var email in standaloneEmails)
        {
            email.IsDisplayedInThread = false;
        }
    }

    public int IndexOf(object item) => Items.IndexOf(item);

    private void RefreshThreadInUI(ThreadMailItemViewModel expander)
    {
        // Remove thread completely from UI
        RemoveThreadFromUI(expander);

        // Find correct position for thread expander based on latest email
        var groupKey = GetGroupKeyForItem(expander);
        AddThreadToUI(expander, groupKey);
    }

    public MailItemContainer GetMailItemContainer(Guid uniqueId)
    {
        // First, search in standalone mail items (not displayed in threads)
        var standaloneMailItem = _sourceItems.FirstOrDefault(item =>
            item.MailCopy.UniqueId == uniqueId && !item.IsDisplayedInThread);

        if (standaloneMailItem != null)
        {
            // Check if the standalone item is visible in the UI
            var isItemVisible = Items.Contains(standaloneMailItem);

            return new MailItemContainer(standaloneMailItem)
            {
                IsItemVisible = isItemVisible,
                IsThreadVisible = false // Not a threaded item
            };
        }

        // Search in thread expanders for threaded mail items
        foreach (var threadExpander in _threadExpanders.Values)
        {
            if (threadExpander.HasUniqueId(uniqueId))
            {
                // Find the specific mail item within the thread
                var threadMailItem = threadExpander.ThreadEmails.FirstOrDefault(email =>
                    email.MailCopy.UniqueId == uniqueId);

                if (threadMailItem != null)
                {
                    // Check visibility: thread expander must be visible, and for individual item visibility,
                    // the thread must be expanded and the item must be in the visible Items collection
                    var isThreadVisible = Items.Contains(threadExpander);
                    var isItemVisible = isThreadVisible && threadExpander.IsThreadExpanded && Items.Contains(threadMailItem);

                    return new MailItemContainer(threadMailItem, threadExpander)
                    {
                        IsItemVisible = isItemVisible,
                        IsThreadVisible = isThreadVisible
                    };
                }
            }
        }

        // Item not found
        return null;
    }

    /// <summary>
    /// Gets the next item in the UI list based on the given MailCopy.
    /// If the next item is a thread, the thread will be expanded and the first item in the thread returned.
    /// </summary>
    /// <param name="mailCopy">The mail copy to find the next item for.</param>
    /// <returns>The next mail item in the UI list, or null if no next item exists.</returns>
    public MailItemViewModel GetNextItem(MailCopy mailCopy)
    {
        if (mailCopy == null)
            return null;

        _isUpdating = true;
        try
        {
            // Find the current item in the UI Items collection
            var currentItemIndex = -1;
            MailItemViewModel currentMailItem = null;
            ThreadMailItemViewModel currentThread = null;

            // First, try to find the item as a standalone email in the Items collection
            for (int i = 0; i < Items.Count; i++)
            {
                var item = Items[i];

                if (item is MailItemViewModel mailItem && mailItem.MailCopy.UniqueId == mailCopy.UniqueId)
                {
                    currentItemIndex = i;
                    currentMailItem = mailItem;
                    break;
                }
            }

            // If not found as standalone, check if it's in a thread
            if (currentItemIndex == -1)
            {
                // Find the thread that contains this mail
                foreach (var expander in _threadExpanders.Values)
                {
                    if (expander.HasUniqueId(mailCopy.UniqueId))
                    {
                        // Find the thread expander in the Items collection
                        currentItemIndex = Items.IndexOf(expander);
                        currentThread = expander;

                        // If thread is expanded, find the specific mail item within the thread
                        if (expander.IsThreadExpanded)
                        {
                            var threadMailItem = expander.ThreadEmails.FirstOrDefault(e => e.MailCopy.UniqueId == mailCopy.UniqueId);
                            if (threadMailItem != null)
                            {
                                currentItemIndex = Items.IndexOf(threadMailItem);
                                currentMailItem = threadMailItem;
                            }
                        }

                        break;
                    }
                }
            }

            // If we still haven't found the item, it's not in the UI
            if (currentItemIndex == -1)
                return null;

            // Look for the next item in the Items collection
            for (int i = currentItemIndex + 1; i < Items.Count; i++)
            {
                var nextItem = Items[i];

                // Skip group headers
                if (nextItem is GroupHeaderBase)
                    continue;

                // If next item is a mail item, return it
                if (nextItem is MailItemViewModel nextMailItem)
                {
                    return nextMailItem;
                }

                // If next item is a thread expander, expand it and return the first item
                if (nextItem is ThreadMailItemViewModel threadExpander)
                {
                    // Expand the thread if not already expanded
                    if (!threadExpander.IsThreadExpanded)
                    {
                        threadExpander.IsThreadExpanded = true;
                    }

                    // Return the first item in the thread (latest email)
                    var sortedThreadEmails = SortDirection == EmailSortDirection.Descending
                        ? threadExpander.ThreadEmails.OrderByDescending(e => e.MailCopy?.CreationDate).ToList()
                        : threadExpander.ThreadEmails.OrderBy(e => e.MailCopy?.CreationDate).ToList();

                    return sortedThreadEmails.FirstOrDefault();
                }
            }

            // No next item found
            return null;
        }
        finally
        {
            _isUpdating = false;
        }
    }

    /// <summary>
    /// Searches for all mail items with a specific FromAddress and toggles their ThumbnailUpdatedEvent property.
    /// This will notify the UI to update thumbnails for all matching items.
    /// </summary>
    /// <param name="fromAddress">The email address to search for in FromAddress property.</param>
    public void UpdateThumbnailsForAddress(string fromAddress)
    {
        if (string.IsNullOrEmpty(fromAddress)) return;

        // Search through all source items (includes both standalone and threaded emails)
        foreach (var mailItem in _sourceItems)
        {
            if (string.Equals(mailItem.MailCopy.FromAddress, fromAddress, StringComparison.OrdinalIgnoreCase))
            {
                // Toggle the ThumbnailUpdatedEvent to notify the UI
                mailItem.ThumbnailUpdatedEvent = !mailItem.ThumbnailUpdatedEvent;
            }
        }
    }

    /// <summary>
    /// Selects all mail items in the collection.
    /// Includes standalone mail items and all mail items inside threads, regardless of thread expansion state.
    /// </summary>
    /// <returns>The number of items that were selected.</returns>
    public int SelectAll()
    {
        var initialSelectedCount = SelectedItems.Count();

        // Select all standalone emails (not in threads)
        foreach (var mailItem in _sourceItems.Where(e => !e.IsDisplayedInThread))
        {
            mailItem.IsSelected = true;
        }

        // Select all thread expanders (which automatically selects all emails within them)
        foreach (var expander in _threadExpanders.Values)
        {
            expander.IsSelected = true;
        }

        SelectedVisibleCount = _selectedVisibleItems.Count;

        var finalSelectedCount = SelectedItems.Count();
        var selectedCount = finalSelectedCount - initialSelectedCount;

        if (selectedCount > 0)
        {
            SelectionChanged?.Invoke(this, EventArgs.Empty);
        }

        return selectedCount;
    }

    /// <summary>
    /// Clears the selection of all mail items in the collection.
    /// Includes standalone mail items and all mail items inside threads, regardless of thread expansion state.
    /// </summary>
    /// <returns>The number of items that were deselected.</returns>
    public int ClearSelections()
    {
        var initialSelectedCount = SelectedItems.Count();

        // Deselect all standalone emails (not in threads)
        foreach (var mailItem in _sourceItems.Where(e => !e.IsDisplayedInThread))
        {
            mailItem.IsSelected = false;
        }

        // Deselect all thread expanders and individual emails in threads
        foreach (var expander in _threadExpanders.Values)
        {
            expander.IsSelected = false;

            // Also explicitly deselect individual emails within threads
            foreach (var threadEmail in expander.ThreadEmails)
            {
                threadEmail.IsSelected = false;
            }
        }

        SelectedVisibleCount = _selectedVisibleItems.Count;

        var finalSelectedCount = SelectedItems.Count();
        var deselectedCount = initialSelectedCount - finalSelectedCount;

        if (deselectedCount > 0)
        {
            SelectionChanged?.Invoke(this, EventArgs.Empty);
        }

        return deselectedCount;
    }

    private void AddThreadToUI(ThreadMailItemViewModel expander, string groupKey)
    {
        var groupHeader = GetOrCreateGroupHeader(groupKey);
        var headerIndex = _groupHeaderIndexCache.GetValueOrDefault(groupKey, -1);

        if (headerIndex == -1)
        {
            // New group - add header, expander, and thread emails (if expanded)
            var insertPosition = FindGroupInsertionPosition(groupKey);

            Items.Insert(insertPosition, groupHeader);
            Items.Insert(insertPosition + 1, expander);

            var currentIndex = insertPosition + 2;
            var totalInserted = 2 // header + expander
                ;

            // Only add thread emails if the thread is expanded
            if (expander.IsThreadExpanded)
            {
                var sortedThreadEmails = SortDirection == EmailSortDirection.Descending
                    ? expander.ThreadEmails.OrderByDescending(e => e.MailCopy?.CreationDate).ToList()
                    : expander.ThreadEmails.OrderBy(e => e.MailCopy?.CreationDate).ToList();

                foreach (var email in sortedThreadEmails)
                {
                    Items.Insert(currentIndex, email);
                    RegisterMailItemForSelectionTracking(email);
                    currentIndex++;
                    totalInserted++;
                }
            }

            UpdateHeaderIndicesAfterInsertion(insertPosition, totalInserted);
            _groupHeaderIndexCache[groupKey] = insertPosition;
        }
        else
        {
            // Existing group - find correct position within group
            var groupEndIndex = FindGroupEndIndex(headerIndex);
            var insertIndex = FindItemInsertionIndexInGroup(expander, headerIndex, groupEndIndex);

            // Insert expander
            Items.Insert(insertIndex, expander);
            var currentIndex = insertIndex + 1;
            var totalInserted = 1 // expander
                ;

            // Only insert thread emails if expanded
            if (expander.IsThreadExpanded)
            {
                var sortedThreadEmails = SortDirection == EmailSortDirection.Descending
                    ? expander.ThreadEmails.OrderByDescending(e => e.MailCopy?.CreationDate).ToList()
                    : expander.ThreadEmails.OrderBy(e => e.MailCopy?.CreationDate).ToList();

                foreach (var email in sortedThreadEmails)
                {
                    Items.Insert(currentIndex, email);
                    RegisterMailItemForSelectionTracking(email);
                    currentIndex++;
                    totalInserted++;
                }
            }

            UpdateHeaderIndicesAfterInsertion(insertIndex, totalInserted);
        }

        UpdateGroupHeaderCounts(groupKey, groupHeader);
    }

    private void RemoveThreadFromUI(ThreadMailItemViewModel expander)
    {
        // Remove expander
        var expanderIndex = Items.IndexOf(expander);
        if (expanderIndex >= 0)
        {
            Items.RemoveAt(expanderIndex);
            UpdateHeaderIndicesAfterRemoval(expanderIndex);
        }

        // Remove all thread emails (whether expanded or not)
        foreach (var email in expander.ThreadEmails.ToList())
        {
            var emailIndex = Items.IndexOf(email);
            if (emailIndex >= 0)
            {
                UnregisterMailItemFromSelectionTracking(email);
                Items.RemoveAt(emailIndex);
                UpdateHeaderIndicesAfterRemoval(emailIndex);
            }
        }
    }

    private void RemoveEmailFromUI(MailItemViewModel email)
    {
        var itemIndex = Items.IndexOf(email);
        if (itemIndex >= 0)
        {
            UnregisterMailItemFromSelectionTracking(email);
            Items.RemoveAt(itemIndex);
            UpdateHeaderIndicesAfterRemoval(itemIndex);
        }
    }

    private void AddEmailToUI(MailItemViewModel email)
    {
        var groupKey = GetGroupKey(email);
        var groupHeader = GetOrCreateGroupHeader(groupKey);
        var headerIndex = _groupHeaderIndexCache.GetValueOrDefault(groupKey, -1);

        if (headerIndex == -1)
        {
            // New group
            var insertPosition = FindGroupInsertionPosition(groupKey);
            Items.Insert(insertPosition, groupHeader);
            Items.Insert(insertPosition + 1, email);
            RegisterMailItemForSelectionTracking(email);

            UpdateHeaderIndicesAfterInsertion(insertPosition, 2);
            _groupHeaderIndexCache[groupKey] = insertPosition;
        }
        else
        {
            // Existing group
            var groupEndIndex = FindGroupEndIndex(headerIndex);
            var insertIndex = FindItemInsertionIndexInGroup(email, headerIndex, groupEndIndex);
            Items.Insert(insertIndex, email);
            RegisterMailItemForSelectionTracking(email);

            UpdateHeaderIndicesAfterInsertion(insertIndex);
        }

        UpdateGroupHeaderCounts(groupKey, groupHeader);
    }

    #region Helper Methods

    private string GetGroupKeyForItem(object item)
    {
        return item switch
        {
            MailItemViewModel email => GetGroupKey(email),
            ThreadMailItemViewModel expander => GetGroupKey(expander.ThreadEmails.OrderByDescending(e => e.MailCopy?.CreationDate).First()),
            _ => "Default"
        };
    }

    private string GetGroupKey(MailItemViewModel email)
    {
        return GroupingType switch
        {
            EmailGroupingType.ByFromName => email.FromName ?? "Unknown Sender",
            EmailGroupingType.ByDate => email.MailCopy?.CreationDate.ToString("yyyy-MM-dd") ?? DateTime.Today.ToString("yyyy-MM-dd"),
            _ => "Default"
        };
    }

    private DateTime GetEffectiveDate(object item)
    {
        return item switch
        {
            MailItemViewModel email => email.MailCopy?.CreationDate ?? DateTime.MinValue,
            ThreadMailItemViewModel expander => expander.LatestMailViewModel?.CreationDate ?? DateTime.MinValue,
            _ => DateTime.MinValue
        };
    }

    private int FindInsertionIndex(MailItemViewModel email)
    {
        var createdAt = email.MailCopy!.CreationDate;
        int left = 0, right = _sourceItems.Count;

        while (left < right)
        {
            int mid = (left + right) / 2;
            var comparison = createdAt.CompareTo(_sourceItems[mid].MailCopy?.CreationDate ?? DateTime.MinValue);

            if (SortDirection == EmailSortDirection.Descending)
                comparison = -comparison;

            if (comparison < 0)
                right = mid;
            else
                left = mid + 1;
        }

        return left;
    }

    private GroupHeaderBase GetOrCreateGroupHeader(string groupKey)
    {
        if (!_groupHeaders.TryGetValue(groupKey, out var groupHeader))
        {
            groupHeader = CreateGroupHeader(groupKey);
            _groupHeaders[groupKey] = groupHeader;
            _groupItems[groupKey] = [];
        }
        return groupHeader;
    }

    private GroupHeaderBase CreateGroupHeader(string groupKey)
    {
        return GroupingType switch
        {
            EmailGroupingType.ByFromName => new SenderGroupHeader(groupKey),
            EmailGroupingType.ByDate when DateTime.TryParse(groupKey, out var date) => new DateGroupHeader(date),
            EmailGroupingType.ByDate => new DateGroupHeader(DateTime.Today),
            _ => new SenderGroupHeader(groupKey)
        };
    }

    private IComparer<string> GetGroupComparer()
    {
        return GroupingType switch
        {
            EmailGroupingType.ByFromName => SortDirection == EmailSortDirection.Descending
                ? StringComparer.OrdinalIgnoreCase.Reverse()
                : StringComparer.OrdinalIgnoreCase,
            EmailGroupingType.ByDate => SortDirection == EmailSortDirection.Descending
                ? CreateDateComparer(descending: true)
                : CreateDateComparer(descending: false),
            _ => StringComparer.Ordinal
        };
    }

    private static IComparer<string> CreateDateComparer(bool descending)
    {
        return Comparer<string>.Create((x, y) =>
        {
            var dateX = DateTime.TryParse(x, out var dx) ? dx : DateTime.MinValue;
            var dateY = DateTime.TryParse(y, out var dy) ? dy : DateTime.MinValue;

            var result = dateX.CompareTo(dateY);
            return descending ? -result : result;
        });
    }

    private int FindGroupInsertionPosition(string groupKey)
    {
        var comparer = GetGroupComparer();

        if (_groupHeaderIndexCache.Count == 0)
            return 0;

        var sortedGroups = _groupHeaderIndexCache.Keys.OrderBy(k => k, comparer).ToList();
        var insertPosition = 0;

        for (int i = 0; i < sortedGroups.Count; i++)
        {
            var existingGroupKey = sortedGroups[i];
            var comparison = comparer.Compare(groupKey, existingGroupKey);

            if (comparison < 0)
            {
                insertPosition = _groupHeaderIndexCache[existingGroupKey];
                break;
            }
            else if (i == sortedGroups.Count - 1)
            {
                var lastGroupHeaderIndex = _groupHeaderIndexCache[existingGroupKey];
                var lastGroupItemCount = _groupItems[existingGroupKey].Count;
                insertPosition = lastGroupHeaderIndex + 1 + lastGroupItemCount;
            }
        }

        return insertPosition;
    }

    private int FindGroupEndIndex(int headerIndex)
    {
        var groupKey = string.Empty;
        foreach (var kvp in _groupHeaderIndexCache)
        {
            if (kvp.Value == headerIndex)
            {
                groupKey = kvp.Key;
                break;
            }
        }

        return headerIndex + 1 + _groupItems.GetValueOrDefault(groupKey, []).Count;
    }

    private int FindItemInsertionIndexInGroup(object item, int groupStartIndex, int groupEndIndex)
    {
        var itemDate = GetEffectiveDate(item);

        for (int i = groupStartIndex + 1; i < groupEndIndex; i++)
        {
            var existingItem = Items[i];
            var existingDate = GetEffectiveDate(existingItem);

            var comparison = itemDate.CompareTo(existingDate);
            if (SortDirection == EmailSortDirection.Descending)
                comparison = -comparison;

            if (comparison < 0)
                return i;
        }

        return groupEndIndex;
    }

    private void UpdateHeaderIndicesAfterInsertion(int insertIndex, int itemCount = 1)
    {
        var keysToUpdate = _groupHeaderIndexCache
            .Where(kvp => kvp.Value > insertIndex)
            .Select(kvp => kvp.Key)
            .ToList();

        foreach (var key in keysToUpdate)
        {
            _groupHeaderIndexCache[key] += itemCount;
        }
    }

    private void UpdateHeaderIndicesAfterRemoval(int removeIndex)
    {
        var keysToUpdate = _groupHeaderIndexCache
            .Where(kvp => kvp.Value > removeIndex)
            .Select(kvp => kvp.Key)
            .ToList();

        foreach (var key in keysToUpdate)
        {
            _groupHeaderIndexCache[key]--;
        }
    }

    private void UpdateAllGroupHeaderCounts()
    {
        foreach (var (groupKey, groupHeader) in _groupHeaders)
        {
            UpdateGroupHeaderCounts(groupKey, groupHeader);
        }
    }

    private void UpdateGroupHeaderCounts(string groupKey, GroupHeaderBase groupHeader)
    {
        var emailsInGroup = _sourceItems.Where(e => GetGroupKey(e) == groupKey).ToList();
        var expandersInGroup = _threadExpanders.Values
            .Where(exp => GetGroupKeyForItem(exp) == groupKey)
            .ToList();

        var totalEmailCount = emailsInGroup.Count;
        var unreadCount = emailsInGroup.Count(e => e.MailCopy?.IsRead == false);

        groupHeader.ItemCount = totalEmailCount;
        groupHeader.UnreadCount = unreadCount;
    }

    private void UpdateGroupAfterChanges()
    {
        // Update all group header counts and remove empty groups
        var groupsToRemove = new List<string>();

        foreach (var (groupKey, groupHeader) in _groupHeaders.ToList())
        {
            UpdateGroupHeaderCounts(groupKey, groupHeader);

            if (groupHeader.ItemCount == 0)
            {
                groupsToRemove.Add(groupKey);
            }
        }

        foreach (var groupKey in groupsToRemove)
        {
            RemoveGroupHeader(groupKey);
        }
    }

    private void RemoveGroupHeader(string groupKey)
    {
        if (_groupHeaderIndexCache.TryGetValue(groupKey, out var headerIndex))
        {
            Items.RemoveAt(headerIndex);
            UpdateHeaderIndicesAfterRemoval(headerIndex);

            _groupHeaderIndexCache.Remove(groupKey);
            _groupHeaders.Remove(groupKey);
            _groupItems.Remove(groupKey);
        }
    }

    #region Incremental Refresh Helper Methods

    /// <summary>
    /// Updates thread expanders when new emails are added
    /// </summary>
    private void UpdateThreadExpandersForNewEmails(IList<MailItemViewModel> newEmails)
    {
        // Group new emails by ThreadId
        var newThreadGroups = newEmails
            .Where(e => !string.IsNullOrEmpty(e.MailCopy?.ThreadId))
            .GroupBy(e => e.MailCopy!.ThreadId!)
            .ToList();

        foreach (var threadGroup in newThreadGroups)
        {
            var threadId = threadGroup.Key;

            if (_threadExpanders.TryGetValue(threadId, out var existingExpander))
            {
                // Add new emails to existing thread
                foreach (var email in threadGroup)
                {
                    existingExpander.AddEmail(email);
                    email.IsDisplayedInThread = true;
                }
            }
            else
            {
                // Check if we need to create a new thread with existing emails
                var existingEmailsInThread = _sourceItems
                    .Where(e => e.MailCopy?.ThreadId == threadId && !threadGroup.Contains(e))
                    .ToList();

                var allThreadEmails = existingEmailsInThread.Concat(threadGroup).ToList();

                if (allThreadEmails.Count >= 2)
                {
                    // Create new thread expander
                    var expander = new ThreadMailItemViewModel(threadId);
                    _threadExpanders[threadId] = expander;

                    // Add all emails to the thread
                    foreach (var email in allThreadEmails)
                    {
                        expander.AddEmail(email);
                        email.IsDisplayedInThread = true;
                    }
                }
            }
        }
    }

    /// <summary>
    /// Finds the correct position to insert an email in the UI Items collection
    /// </summary>
    private int FindUIInsertionPosition(MailItemViewModel email, string groupKey)
    {
        // If group doesn't exist yet, find position for new group
        if (!_groupHeaderIndexCache.ContainsKey(groupKey))
        {
            return FindGroupInsertionPosition(groupKey);
        }

        var headerIndex = _groupHeaderIndexCache[groupKey];
        var groupEndIndex = FindGroupEndIndex(headerIndex);

        return FindItemInsertionIndexInGroup(email, headerIndex, groupEndIndex);
    }

    /// <summary>
    /// Finds the correct position to insert an email within a group's items list
    /// </summary>
    private int FindGroupInsertionIndex(MailItemViewModel email, List<object> groupItems)
    {
        var emailDate = email.MailCopy?.CreationDate ?? DateTime.MinValue;

        for (int i = 0; i < groupItems.Count; i++)
        {
            var existingDate = GetEffectiveDate(groupItems[i]);
            var comparison = emailDate.CompareTo(existingDate);

            if (SortDirection == EmailSortDirection.Descending)
                comparison = -comparison;

            if (comparison < 0)
                return i;
        }

        return groupItems.Count;
    }

    /// <summary>
    /// Finds the correct position to insert a group header
    /// </summary>
    private int FindHeaderInsertionPosition(string groupKey, GroupHeaderBase groupHeader)
    {
        if (_groupHeaderIndexCache.Count == 0)
            return 0;

        var comparer = GetGroupComparer();
        var insertPosition = 0;

        foreach (var kvp in _groupHeaderIndexCache.OrderBy(k => k.Key, comparer))
        {
            var existingGroupKey = kvp.Key;
            var comparison = comparer.Compare(groupKey, existingGroupKey);

            if (comparison < 0)
            {
                insertPosition = kvp.Value;
                break;
            }
            else
            {
                var groupEndIndex = FindGroupEndIndex(kvp.Value);
                insertPosition = groupEndIndex;
            }
        }

        return insertPosition;
    }

    /// <summary>
    /// Updates header indices after a new group is inserted
    /// </summary>
    private void UpdateSubsequentHeaderIndices(string insertedGroupKey, int itemCount)
    {
        var insertedHeaderIndex = _groupHeaderIndexCache[insertedGroupKey];

        var keysToUpdate = _groupHeaderIndexCache
            .Where(kvp => kvp.Key != insertedGroupKey && kvp.Value > insertedHeaderIndex)
            .Select(kvp => kvp.Key)
            .ToList();

        foreach (var key in keysToUpdate)
        {
            _groupHeaderIndexCache[key] += itemCount;
        }
    }

    /// <summary>
    /// Updates group header counts for affected groups when new emails are added
    /// </summary>
    private void UpdateGroupHeaderCountsForNewEmails(IList<MailItemViewModel> newEmails)
    {
        var affectedGroups = newEmails
            .Select(email => GetGroupKey(email))
            .Distinct()
            .ToList();

        foreach (var groupKey in affectedGroups)
        {
            if (_groupHeaders.TryGetValue(groupKey, out var groupHeader))
            {
                UpdateGroupHeaderCounts(groupKey, groupHeader);
            }
        }
    }

    #endregion

    private void OnSourceItemsChanged(object sender, NotifyCollectionChangedEventArgs e)
    {
        if (!_isUpdating)
        {
            RefreshGrouping();
        }
    }

    #endregion

    protected virtual void Dispose(bool disposing)
    {
        if (_disposed)
            return;

        if (disposing)
        {
            _sourceItems.CollectionChanged -= OnSourceItemsChanged;

            // Unregister all mail items from selection tracking
            foreach (var item in Items)
            {
                if (item is MailItemViewModel mailItem)
                {
                    UnregisterMailItemFromSelectionTracking(mailItem);
                }
            }

            // Unregister from messenger
            WeakReferenceMessenger.Default.Unregister<PropertyChangedMessage<bool>>(this);

            // Reset IsDisplayedInThread for all emails before disposal
            foreach (var email in _sourceItems)
            {
                email.IsDisplayedInThread = false;
            }

            // Dispose all thread expanders
            foreach (var expander in _threadExpanders.Values)
            {
                expander.Dispose();
            }

            _sourceItems.Clear();
            Items.Clear();
            _groupHeaders.Clear();
            _groupHeaderIndexCache.Clear();
            _groupItems.Clear();
            _threadExpanders.Clear();
            _selectedVisibleItems.Clear();
            SelectedVisibleCount = 0;
        }

        _disposed = true;
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
}

/// <summary>
/// Extension method to reverse IComparer for descending sorts
/// </summary>
internal static class ComparerExtensions
{
    public static IComparer<T> Reverse<T>(this IComparer<T> comparer)
    {
        return Comparer<T>.Create((x, y) => comparer.Compare(y, x));
    }
}