using AllBase.Helper;
using AllBase.Model.DBModel;
using Microsoft.Win32;
using OrderSupportTicket.Models;
using OrderSupportTicket.Models.Api;
using OrderSupportTicket.Services;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
using System.Windows.Data;
using System.Windows.Media;
using System.Windows.Threading;
using WPFCommon.Models;
using WxOrder.Framework.Commons;
using WxOrder.Framework.Commons.Dialogs;
using WxOrder.Framework.Controls;

namespace OrderSupportTicket.ViewModels;

/// <summary>
/// 工单页总 ViewModel，负责工单查询、留言操作、新建工单和 SSE 刷新。
/// </summary>
public sealed class OrderSupportTicketViewModel : BindableBaseEx, IDialogAware, IDisposable
{
    /// <summary>
    /// 新建工单弹窗中传入 <see cref="TicketOrderOption"/> 的参数名。
    /// </summary>
    public const string OrderParameterKey = "order";

    private readonly TicketService _ticketService;
    private readonly WorkOrderCacheService _cacheService = new WorkOrderCacheService();
    private readonly Dispatcher _dispatcher;
    private readonly AsyncDelegateCommand<WorkOrderSummaryViewModel> _selectTicketCommand;
    private readonly AsyncDelegateCommand _createTicketCommand;
    private readonly AsyncDelegateCommand _sendMessageCommand;
    private readonly AsyncDelegateCommand<PendingAttachmentViewModel> _removePendingAttachmentCommand;
    private readonly AsyncDelegateCommand _loadEarlierMessagesCommand;
    private readonly AsyncDelegateCommand _refreshMessagesCommand;
    private readonly AsyncDelegateCommand _retryRealtimeCommand;
	private readonly DelegateCommand<FrameworkElement> _addImagesCommand;
    private readonly HashSet<string> _seenEventIds =
        new HashSet<string>(StringComparer.Ordinal);
    private readonly Dictionary<string, int> _lastReadSequences =
        new Dictionary<string, int>(StringComparer.Ordinal);
    private Dictionary<string, WorkOrderListCacheItem> _savedWorkOrders =
        new Dictionary<string, WorkOrderListCacheItem>(StringComparer.Ordinal);
    // 按 APPID 和订单号隔离各工单消息，切换会话不丢失推送。
    private readonly Dictionary<string, Dictionary<string, TicketMessageDto>> _conversationMessages =
        new Dictionary<string, Dictionary<string, TicketMessageDto>>(StringComparer.Ordinal);
    private readonly Dictionary<string, WorkOrderMessagesResponse> _conversationPages = new Dictionary<string, WorkOrderMessagesResponse>(StringComparer.Ordinal);
    private readonly Dictionary<string, Task> _conversationLoads = new Dictionary<string, Task>(StringComparer.Ordinal);
    private bool IsRealtimeConversation => _options?.ConversationMode == TicketConversationMode.Realtime;
    private bool _hasSavedCache;
    private TicketClientOptions _options;
    private bool _configured;
    private bool _initialized;
    private bool _disposed;
    private string _pendingOpenKey;
    private WorkOrderSummaryViewModel _selectedTicket;
    private TicketOrderOption _selectedOrder;
    private ImageSource _selectedOrderImage;
    private int _selectedOrderImageVersion;
    private string _chatText;
    private string _draftText;
    private string _ticketSearchText = string.Empty;
    private int _selectedTicketStatusIndex;
    private bool _isDraft;
    private bool _isBusy;
    private bool _isLoading;
    private bool _isLoadingMessages;
    private bool _hasMoreMessages;
    private string _nextBefore;
    private string _noticeText;
    private bool _isNoticeError;
    private bool _hasNewData;
    private string _newDataText;
    private bool _isWindowActive;
    private TicketRealtimeState _sseState;
    private string _sseStatusText;
    private int _messageScrollVersion;
    private string _pendingCreateRequestId;
    private string _pendingCreateFingerprint;
    private string _pendingMessageId;
    private string _pendingMessageFingerprint;
    private int _selectionVersion;

    public OrderSupportTicketViewModel(
        TicketService ticketService,
        TicketClientOptions options = null)
    {
        _ticketService = ticketService
            ?? throw new ArgumentNullException(nameof(ticketService));
        _dispatcher = System.Windows.Application.Current?.Dispatcher
            ?? Dispatcher.CurrentDispatcher;

        Tickets = new ObservableCollection<WorkOrderSummaryViewModel>();
        Messages = new ObservableCollection<ChatMessageViewModel>();
        PendingAttachments = new ObservableCollection<PendingAttachmentViewModel>();
        TicketView = CollectionViewSource.GetDefaultView(Tickets);
        TicketView.Filter = FilterTicket;
        _selectTicketCommand = new AsyncDelegateCommand<WorkOrderSummaryViewModel>(
            SelectTicketAsync,
            ticket => ticket != null && !IsBusy);
        _createTicketCommand = new AsyncDelegateCommand(
            CreateTicketAsync,
            CanCreateTicket);
        _sendMessageCommand = new AsyncDelegateCommand(
            SendMessageAsync,
            CanSendMessage);
        _removePendingAttachmentCommand =
            new AsyncDelegateCommand<PendingAttachmentViewModel>(
                RemovePendingAttachmentAsync,
                attachment => attachment != null && !IsBusy);
        _loadEarlierMessagesCommand = new AsyncDelegateCommand(
            LoadEarlierMessagesAsync,
            () => !IsBusy && SelectedTicket != null && HasMoreMessages);
        _refreshMessagesCommand = new AsyncDelegateCommand(
            RefreshMessagesAsync,
            () => _configured && !IsBusy && !IsLoadingMessages && !IsDraft && SelectedTicket != null);
        _retryRealtimeCommand = new AsyncDelegateCommand(
            RestartRealtimeAsync,
            () => _configured);
		_addImagesCommand = new DelegateCommand<FrameworkElement>(
			AddImages,
			_ => CanAddImage);
        _ticketService.NotificationReceived += OnNotificationReceived;
        _ticketService.StateChanged += OnRealtimeStateChanged;
        SseState = _ticketService.RealtimeState;
        SseStatusText = GetRealtimeStatusText(SseState);

        if (options != null)
            Configure(options);
    }

    /// <summary>
    /// 当前账号和 APPID 下的历史工单。
    /// </summary>
    public ObservableCollection<WorkOrderSummaryViewModel> Tickets { get; }

    /// <summary>
    /// 经过搜索条件过滤后的历史工单。
    /// </summary>
    public ICollectionView TicketView { get; }

    /// <summary>
    /// 当前选中工单的公开留言。
    /// </summary>
    public ObservableCollection<ChatMessageViewModel> Messages { get; }

    /// <summary>
    /// 选择并加载历史工单的命令。
    /// </summary>
    public ICommand SelectTicketCommand => _selectTicketCommand;

    /// <summary>
    /// 提交新工单的命令。
    /// </summary>
    public ICommand CreateTicketCommand => _createTicketCommand;

    /// <summary>
    /// 提交客户留言的命令。
    /// </summary>
    public ICommand SendMessageCommand => _sendMessageCommand;

    /// <summary>
    /// 移除待发送图片的命令。
    /// </summary>
    public ICommand RemovePendingAttachmentCommand => _removePendingAttachmentCommand;

    /// <summary>
    /// 当前留言待发送的本地图片，最多 3 张。
    /// </summary>
    public ObservableCollection<PendingAttachmentViewModel> PendingAttachments { get; }

    /// <summary>
    /// 是否已选择待发送图片。
    /// </summary>
    public bool HasPendingAttachments => PendingAttachments.Count > 0;

    /// <summary>
    /// 是否还可以继续选择图片。
    /// </summary>
    public bool CanAddImage =>
        !IsBusy
        && SelectedTicket != null
        && PendingAttachments.Count < TicketApiService.MaxImageCount;

	/// <summary>
	/// 选择本地图片并加入当前留言的待发送列表。
	/// </summary>
	public ICommand AddImagesCommand => _addImagesCommand;

    /// <summary>
    /// 待发送图片数量展示文本。
    /// </summary>
    public string AttachmentCountText =>
        PendingAttachments.Count + " / " + TicketApiService.MaxImageCount;

    /// <summary>
    /// 加载当前工单更早留言的命令。
    /// </summary>
    public ICommand LoadEarlierMessagesCommand => _loadEarlierMessagesCommand;

    /// <summary>强制重新获取当前工单消息，两种会话模式均不使用缓存代替请求。</summary>
    public ICommand RefreshMessagesCommand => _refreshMessagesCommand;

    /// <summary>
    /// 手动重新连接 SSE 的命令。
    /// </summary>
    public ICommand RetryRealtimeCommand => _retryRealtimeCommand;

	/// <summary>
	/// 显示图片
	/// </summary>
	public ICommand ShowImageWindowCommand => new DelegateCommand<ChatAttachmentViewModel>(ShowImageWindow);
	/// <summary>
	/// 显示图片
	/// </summary>
	/// <param name="chatAttachment"></param>
	private void ShowImageWindow(ChatAttachmentViewModel chatAttachment)
	{
		ImageViewerWindow.OpenDialog(chatAttachment.Image);	
	}

	/// <summary>
	/// 当前正在查看的历史工单。
	/// </summary>
	public WorkOrderSummaryViewModel SelectedTicket
    {
        get => _selectedTicket;
        private set
        {
            if (SetValue(ref _selectedTicket, value))
            {
                RaisePropertyChanged(nameof(IsChatVisible));
                RaisePropertyChanged(nameof(IsEmptyVisible));
                RaisePropertyChanged(nameof(ComposerPlaceholder));
                RaisePropertyChanged(nameof(CanAddImage));
				_addImagesCommand.RaiseCanExecuteChanged();
                RaiseSendCanExecuteChanged();
                RaiseLoadEarlierCanExecuteChanged();
            }
        }
    }

    /// <summary>
    /// 新建工单时选中的关联订单。
    /// </summary>
    public TicketOrderOption SelectedOrder
    {
        get => _selectedOrder;
        set
        {
            if (SetValue(ref _selectedOrder, value))
            {
                RaisePropertyChanged(nameof(SelectedOrderDescription));
                RaisePropertyChanged(nameof(SelectedOrderText));
                RaiseCreateCanExecuteChanged();
                _ = LoadSelectedOrderImageAsync(value);
            }
        }
    }

    /// <summary>
    /// 当前工单输入框中的留言文本。
    /// </summary>
    public string ChatText
    {
        get => _chatText;
        set
        {
            if (SetValue(ref _chatText, value ?? string.Empty))
            {
                RaisePropertyChanged(nameof(ChatCharacterCountText));
                RaiseSendCanExecuteChanged();
            }
        }
    }

    /// <summary>
    /// 新建工单输入框中的问题描述。
    /// </summary>
    public string DraftText
    {
        get => _draftText;
        set
        {
            if (SetValue(ref _draftText, value ?? string.Empty))
            {
                RaisePropertyChanged(nameof(DraftCharacterCountText));
                RaiseCreateCanExecuteChanged();
            }
        }
    }

    /// <summary>
    /// 历史工单搜索关键词，可匹配订单号、店铺、状态或最近动态。
    /// </summary>
    public string TicketSearchText
    {
        get => _ticketSearchText;
        set
        {
            if (SetValue(ref _ticketSearchText, value ?? string.Empty))
            {
                if (IsDraft)
                    CancelDraft();
                TicketView?.Refresh();
            }
        }
    }

    /// <summary>
    /// 历史工单状态页签索引：0 全部、1 待客服回复、2 客服已回复、3 已完结。
    /// </summary>
    public int SelectedTicketStatusIndex
    {
        get => _selectedTicketStatusIndex;
        set
        {
            if (SetValue(ref _selectedTicketStatusIndex, value))
                TicketView?.Refresh();
        }
    }

    /// <summary>
    /// 当前是否处于新建工单草稿状态。
    /// </summary>
    public bool IsDraft
    {
        get => _isDraft;
        private set
        {
            if (SetValue(ref _isDraft, value))
            {
                RaisePropertyChanged(nameof(IsChatVisible));
                RaisePropertyChanged(nameof(IsEmptyVisible));
                RaisePropertyChanged(nameof(IsDraftVisible));
                RaisePropertyChanged(nameof(CanAddImage));
				_addImagesCommand.RaiseCanExecuteChanged();
                RaiseCreateCanExecuteChanged();
            }
        }
    }

    /// <summary>
    /// 是否正在执行创建、留言或刷新操作。
    /// </summary>
    public bool IsBusy
    {
        get => _isBusy;
        private set
        {
            if (SetValue(ref _isBusy, value))
            {
                RaisePropertyChanged(nameof(IsNotBusy));
                RaisePropertyChanged(nameof(CanAddImage));
                RaiseSendCanExecuteChanged();
                RaiseCreateCanExecuteChanged();
                _removePendingAttachmentCommand.RaiseCanExecuteChanged();
                RaiseLoadEarlierCanExecuteChanged();
                _retryRealtimeCommand.RaiseCanExecuteChanged();
                _selectTicketCommand.RaiseCanExecuteChanged();
				_addImagesCommand.RaiseCanExecuteChanged();
                if (!value && !string.IsNullOrWhiteSpace(_pendingOpenKey))
                    _ = SelectPendingTicketAsync();
            }
        }
    }

    /// <summary>
    /// 是否正在加载工单摘要列表。
    /// </summary>
    public bool IsLoading
    {
        get => _isLoading;
        private set => SetValue(ref _isLoading, value);
    }

    /// <summary>
    /// 是否正在加载当前工单留言。
    /// </summary>
    public bool IsLoadingMessages
    {
        get => _isLoadingMessages;
        private set
        {
            if (SetValue(ref _isLoadingMessages, value))
                _refreshMessagesCommand.RaiseCanExecuteChanged();
        }
    }

    /// <summary>
    /// 当前留言板是否还有更早留言。
    /// </summary>
    public bool HasMoreMessages
    {
        get => _hasMoreMessages;
        private set
        {
            if (SetValue(ref _hasMoreMessages, value))
                RaiseLoadEarlierCanExecuteChanged();
        }
    }

    /// <summary>
    /// 当前操作提示或错误信息。
    /// </summary>
    public string NoticeText
    {
        get => _noticeText;
        private set => SetValue(ref _noticeText, value);
    }

    /// <summary>
    /// 当前提示是否为错误类型。
    /// </summary>
    public bool IsNoticeError
    {
        get => _isNoticeError;
        private set => SetValue(ref _isNoticeError, value);
    }

    /// <summary>
    /// 当前页面是否检测到服务器有新的工单消息。
    /// </summary>
    public bool HasNewData
    {
        get => _hasNewData;
        private set => SetValue(ref _hasNewData, value);
    }

    /// <summary>
    /// 新数据提示文本。
    /// </summary>
    public string NewDataText
    {
        get => _newDataText;
        private set => SetValue(ref _newDataText, value);
    }

    /// <summary>
    /// 工单页所在窗口当前是否处于激活且可见状态。
    /// 未激活时只刷新数据，不把当前工单标记为已读。
    /// </summary>
    public bool IsWindowActive
    {
        get => _isWindowActive;
        set
        {
            if (!SetValue(ref _isWindowActive, value))
                return;
            if (value && _initialized && !IsDraft && SelectedTicket != null)
                _ = MarkSelectedTicketReadAsync();
        }
    }

    /// <summary>
    /// SSE 当前连接状态。
    /// </summary>
    public TicketRealtimeState SseState
    {
        get => _sseState;
        private set => SetValue(ref _sseState, value);
    }

    /// <summary>
    /// SSE 当前状态的中文显示文本。
    /// </summary>
    public string SseStatusText
    {
        get => _sseStatusText;
        private set => SetValue(ref _sseStatusText, value);
    }

    /// <summary>
    /// 触发消息列表滚动到底部的版本号。
    /// </summary>
    public int MessageScrollVersion
    {
        get => _messageScrollVersion;
        private set => SetValue(ref _messageScrollVersion, value);
    }

    /// <summary>
    /// 是否显示当前工单的聊天面板。
    /// </summary>
    public bool IsChatVisible => !IsDraft && SelectedTicket != null;

    /// <summary>
    /// 是否显示新建工单面板。
    /// </summary>
    public bool IsDraftVisible => IsDraft;

    /// <summary>
    /// 是否显示未选择工单时的空状态。
    /// </summary>
    public bool IsEmptyVisible => !IsDraft && SelectedTicket == null;

    /// <summary>
    /// 当前是否没有执行中的操作。
    /// </summary>
    public bool IsNotBusy => !IsBusy;

    /// <summary>
    /// 留言输入框字数统计文本。
    /// </summary>
    public string ChatCharacterCountText => (ChatText ?? string.Empty).Length + " / 4000";

    /// <summary>
    /// 新建工单输入框字数统计文本。
    /// </summary>
    public string DraftCharacterCountText => (DraftText ?? string.Empty).Length + " / 2000";

    /// <summary>
    /// 当前工单输入框提示文本。
    /// </summary>
    public string ComposerPlaceholder =>
        SelectedTicket != null && SelectedTicket.IsCompleted
            ? "工单已完结，继续留言将重新开启"
            : "输入留言";

    /// <summary>
    /// 当前关联订单的商品、金额和下单时间说明。
    /// </summary>
    public string SelectedOrderDescription =>
        SelectedOrder?.ProductDescription ?? "未提供关联订单";

    /// <summary>
    /// 当前关联订单的订单号和商品名摘要。
    /// </summary>
    public string SelectedOrderText =>
        SelectedOrder?.DisplayText ?? "未提供关联订单";

    /// <summary>
    /// 当前关联订单的商品缩略图，加载完成前为空。
    /// </summary>
    public ImageSource SelectedOrderImage
    {
        get => _selectedOrderImage;
        private set => SetValue(ref _selectedOrderImage, value);
    }

    /// <summary>
    /// 弹窗标题。
    /// </summary>
    public string Title => "客户工单";

    /// <summary>
    /// 由 DialogService 绑定，页面本身不主动请求关闭。
    /// </summary>
#pragma warning disable CS0067
    public event Action<IDialogResult> RequestClose;
#pragma warning restore CS0067

    public bool CanCloseDialog()
    {
        return true;
    }

    public void OnDialogOpened(IDialogParameters parameters)
    {
        if (parameters == null)
            return;

        if (parameters.TryGetValue<TicketClientOptions>("options", out var options)
            && options != null)
        {
            Configure(options);
        }

        var order = GetOrderFromParameters(parameters);
        if (order != null)
            OpenNewTicket(order);
    }

    /// <summary>
    /// 从弹窗参数中取出需要新建工单的订单。优先使用订单对象，
    /// 同时兼容按字段传入订单号、APPID 等信息的调用方式。
    /// </summary>
    private static TicketOrderOption GetOrderFromParameters(
        IDialogParameters parameters)
    {
        foreach (var key in new[]
                 {
                     OrderParameterKey,
                     "ticketOrder",
                     "TicketOrderOption"
                 })
        {
            if (parameters.TryGetValue<TicketOrderOption>(key, out var order)
                && order != null)
            {
                return order;
            }
        }

        if (parameters.TryGetValue<TicketClientOptions>("options", out var options)
            && options?.Orders != null)
        {
            var optionOrder = options.Orders.FirstOrDefault(o => o != null);
            if (optionOrder != null)
                return optionOrder;
        }

        foreach (var key in parameters.Keys ?? Enumerable.Empty<string>())
        {
            if (!parameters.TryGetValue<object>(key, out var value))
                continue;

            if (value is TicketOrderOption directOrder)
                return directOrder;

            if (value is TicketClientOptions option)
            {
                var optionOrder = option.Orders?.FirstOrDefault(o => o != null);
                if (optionOrder != null)
                    return optionOrder;
            }
        }

        var appId = GetParameterText(parameters, "appId", "AppId");
        var orderId = GetParameterText(
            parameters,
            "wechatOrderId",
            "orderId",
            "OrderId");
        if (string.IsNullOrWhiteSpace(appId) || string.IsNullOrWhiteSpace(orderId))
            return null;

        decimal.TryParse(
            GetParameterText(parameters, "amount", "Amount"),
            NumberStyles.Number,
            CultureInfo.InvariantCulture,
            out var amount);
        DateTime.TryParse(
            GetParameterText(parameters, "orderedAt", "OrderedAt"),
            CultureInfo.CurrentCulture,
            DateTimeStyles.None,
            out var orderedAt);

        return new TicketOrderOption
        {
            AppId = appId.Trim(),
            OrderId = orderId.Trim(),
            GoodsName = GetParameterText(parameters, "goodsName", "GoodsName"),
            ImageUrl = GetParameterText(parameters, "imageUrl", "ImageUrl"),
            Amount = amount,
            OrderedAt = orderedAt
        };
    }

    private static string GetParameterText(
        IDialogParameters parameters,
        params string[] keys)
    {
        foreach (var key in keys)
        {
            if (parameters.TryGetValue<string>(key, out var value)
                && !string.IsNullOrWhiteSpace(value))
            {
                return value;
            }
        }
        return null;
    }

    /// <summary>
    /// 后台下载关联订单的商品缩略图，避免阻塞界面；切换订单后丢弃过期结果。
    /// </summary>
    private async Task LoadSelectedOrderImageAsync(TicketOrderOption order)
    {
        var version = ++_selectedOrderImageVersion;
        SelectedOrderImage = null;

        var imageUrl = order?.ImageUrl?.Trim();
        if (string.IsNullOrEmpty(imageUrl))
            return;

        var image = await ProductImageLoader.LoadAsync(imageUrl);
        if (image == null || version != _selectedOrderImageVersion || _disposed)
            return;

        try
        {
            await _dispatcher.InvokeAsync(() =>
            {
                if (version == _selectedOrderImageVersion && !_disposed)
                    SelectedOrderImage = image;
            });
        }
        catch
        {
            // 页面关闭过程中忽略图片回填失败。
        }
    }

    public void OnDialogClosed()
    {
        // 工单页面由主窗口持有并复用，关闭弹窗时保留页面状态。
    }

    /// <summary>
    /// 切换回历史工单页面。
    /// </summary>
    public void ShowHistory()
    {
        CancelDraft();
    }

    /// <summary>
    /// 取消尚未提交的新工单草稿。
    /// </summary>
    public void CancelNewTicketDraft()
    {
        CancelDraft();
    }

    /// <summary>
    /// 把文件选择器返回的本地图片加入待发送列表。
    /// 每次留言最多 3 张，单张不超过 5 MiB。
    /// </summary>
    public void AddPendingImages(IEnumerable<string> filePaths)
    {
        if (filePaths == null || IsBusy || IsDraft || SelectedTicket == null)
            return;

        var errors = new List<string>();
        var added = 0;
        foreach (var filePath in filePaths)
        {
            if (PendingAttachments.Count >= TicketApiService.MaxImageCount)
            {
                errors.Add("每次留言最多上传 3 张图片。");
                break;
            }
            if (string.IsNullOrWhiteSpace(filePath))
                continue;

            string fullPath;
            try
            {
                fullPath = Path.GetFullPath(filePath);
            }
            catch
            {
                errors.Add("图片路径无效：" + filePath);
                continue;
            }

            if (PendingAttachments.Any(item =>
                string.Equals(item.FilePath, fullPath, StringComparison.OrdinalIgnoreCase)))
            {
                continue;
            }
            if (!PendingAttachmentViewModel.TryCreate(
                fullPath,
                out var attachment,
                out var error))
            {
                errors.Add(error);
                continue;
            }

            PendingAttachments.Add(attachment);
            added++;
        }

        OnPendingAttachmentsChanged();
        if (errors.Count > 0)
        {
            SetNotice(
                string.Join(" ", errors.Distinct(StringComparer.Ordinal)),
                true);
        }
        else if (added > 0)
        {
            ClearNotice();
        }
    }

	/// <summary>
	/// 将剪贴板中的位图加入待发送列表。
	/// </summary>
	public void AddPendingImage(System.Windows.Media.Imaging.BitmapSource bitmap)
	{
		if (IsBusy || IsDraft || SelectedTicket == null)
			return;
		if (PendingAttachments.Count >= TicketApiService.MaxImageCount)
		{
			SetNotice("每次留言最多上传 3 张图片。", true);
			return;
		}

		if (!PendingAttachmentViewModel.TryCreateTemporary(
			bitmap, out var attachment, out var error))
		{
			SetNotice(error, true);
			return;
		}

		PendingAttachments.Add(attachment);
		OnPendingAttachmentsChanged();
		ClearNotice();
	}

	private void AddImages(FrameworkElement commandSource)
	{
		var dialog = new OpenFileDialog
		{
			Title = "选择图片",
			Filter = "图片文件 (*.jpg;*.jpeg;*.png;*.webp)|*.jpg;*.jpeg;*.png;*.webp",
			CheckFileExists = true,
			Multiselect = true
		};

		var owner = commandSource == null ? null : Window.GetWindow(commandSource);
		var selected = owner == null
			? dialog.ShowDialog()
			: dialog.ShowDialog(owner);
		if (selected == true)
			AddPendingImages(dialog.FileNames);
	}

    private Task RemovePendingAttachmentAsync(
        PendingAttachmentViewModel attachment)
    {
        if (attachment == null)
            return Task.CompletedTask;

        if (PendingAttachments.Remove(attachment))
			attachment.Dispose();
        OnPendingAttachmentsChanged();
        ClearNotice();
        return Task.CompletedTask;
    }

    private void ClearPendingAttachments()
    {
		foreach (var attachment in PendingAttachments)
			attachment.Dispose();
        if (PendingAttachments.Count > 0)
            PendingAttachments.Clear();
        _pendingMessageFingerprint = null;
        _pendingMessageId = null;
        OnPendingAttachmentsChanged();
    }

    private void OnPendingAttachmentsChanged()
    {
        RaisePropertyChanged(nameof(HasPendingAttachments));
        RaisePropertyChanged(nameof(CanAddImage));
        RaisePropertyChanged(nameof(AttachmentCountText));
        RaiseSendCanExecuteChanged();
        _removePendingAttachmentCommand.RaiseCanExecuteChanged();
		_addImagesCommand.RaiseCanExecuteChanged();
    }

    public void Configure(TicketClientOptions options)
    {
        if (_disposed)
            throw new ObjectDisposedException(nameof(OrderSupportTicketViewModel));

        if (_ticketService.OwnsRealtime)
        {
            _ = _ticketService.StopRealtimeAsync();
            SseState = TicketRealtimeState.Disconnected;
        }
        else
        {
            SseState = _ticketService.RealtimeState;
        }
        SseStatusText = GetRealtimeStatusText(SseState);
        _configured = false;
        _initialized = false;
        _pendingOpenKey = null;
        _options = CloneOptions(options);
        _conversationMessages.Clear();
        _conversationPages.Clear();
        _conversationLoads.Clear();
        _seenEventIds.Clear();
        _lastReadSequences.Clear();
        HasNewData = false;
        NewDataText = string.Empty;

        IsDraft = false;
        SelectedTicket = null;
        SelectedOrder = null;
        DraftText = string.Empty;
        Tickets.Clear();
        Messages.Clear();
        ClearPendingAttachments();

        if (_options.AppIds == null || _options.AppIds.Count == 0)
        {
            _options.AppIds = (_options.Orders ?? Enumerable.Empty<TicketOrderOption>())
                .Where(o => o != null)
                .Select(o => o.AppId)
                .Where(a => !string.IsNullOrWhiteSpace(a))
                .Select(a => a.Trim())
                .Distinct(StringComparer.Ordinal)
                .ToList();
        }

        LoadSavedOrderTimes();
        ApplyOptionsValidation();
    }

    private void ApplyOptionsValidation()
    {
        try
        {
            _ticketService.ValidateOptions(_options);
            if (_options.AppIds == null || _options.AppIds.Count == 0)
                throw new ArgumentException("appIds 至少需要一个 APPID。");
            _configured = true;
            NoticeText = string.Empty;
            IsNoticeError = false;
        }
        catch (Exception ex)
        {
            _configured = false;
            SetNotice(
                "工单页配置不完整：" + ex.Message
                + " 请通过 TicketClientOptions 注入拍单账号和 APPID。",
                true);
        }

        RaiseCreateCanExecuteChanged();
        RaiseLoadEarlierCanExecuteChanged();
        _retryRealtimeCommand.RaiseCanExecuteChanged();
    }

    public async Task InitializeAsync()
    {
        if (_disposed)
            return;
        if (!_configured)
        {
            SetNotice(
                "未配置拍单账号或 APPID，工单页无法连接服务器。",
                true);
            return;
        }

        try
        {
            var started = false;
            // 共享连接由宿主统一维护，页面首次打开时不能因为 _initialized=false 重启连接。
            var shouldStartRealtime =
                _ticketService.RealtimeState == TicketRealtimeState.Disconnected
                || (_ticketService.OwnsRealtime && !_initialized);
            if (shouldStartRealtime)
            {
                await _ticketService.StartRealtime(_options);
                started = true;
            }

            if (!_initialized || started)
            {
                // 会话模式不改变初始化列表和历史对话加载流程。
                await RefreshAllWorkOrdersAsync(loadSelectedMessages: true);
                _initialized = true;
            }

            await SelectPendingTicketAsync();
        }
        catch (Exception ex)
        {
            SetNotice(DescribeException(ex), true);
        }
    }

    public async Task DeactivateAsync()
    {
        SaveWorkOrderList();
        if (_ticketService.OwnsRealtime)
            await _ticketService.StopRealtimeAsync();
    }

    public void OpenNewTicket(TicketOrderOption order)
    {
        if (order == null)
            return;

        RememberOrderInfo(order);
        CancelDraft();
        TicketSearchText = string.Empty;
        SelectedOrder = order;
        EnsureOrderAppId(order.AppId);
        OpenNewDraft();
    }

    /// <summary>
    /// 订单列表异步加载完成后，将商品名称、图片和价格补充到对应工单。
    /// </summary>
    public void ApplyOrderInfo(TicketOrderOption order)
    {
        if (order == null || string.IsNullOrWhiteSpace(order.OrderId))
            return;

        RememberOrderInfo(order);

        var ticket = Tickets.FirstOrDefault(t =>
            string.Equals(t.WechatOrderId, order.OrderId, StringComparison.Ordinal)
            && (string.IsNullOrWhiteSpace(order.AppId)
                || string.Equals(t.AppId, order.AppId, StringComparison.Ordinal)));
        if (ticket == null)
            return;

        ticket.ApplyProductInfo(order.GoodsName, order.ImageUrl, order.Amount);
        TicketView.Refresh();
        SaveWorkOrderList();
    }

    private void EnsureOrderAppId(string appId)
    {
        if (_options == null || string.IsNullOrWhiteSpace(appId))
            return;

        if (_options.AppIds == null)
            _options.AppIds = new List<string>();

        if (!_options.AppIds.Any(id =>
            string.Equals(id, appId, StringComparison.Ordinal)))
        {
            _options.AppIds.Add(appId);
        }

        if (!_configured)
            ApplyOptionsValidation();
    }

    /// <summary>
    /// 打开指定工单；页面尚未初始化时会在首次加载完成后自动定位。
    /// </summary>
    public void OpenTicket(string appId, string wechatOrderId)
    {
        if (_disposed || !_configured)
            return;
        if (string.IsNullOrWhiteSpace(appId) || string.IsNullOrWhiteSpace(wechatOrderId))
            return;

        _pendingOpenKey = appId + "|" + wechatOrderId;
        if (_initialized)
            _ = SelectPendingTicketAsync();
    }

    /// <summary>
    /// 按订单号查找历史工单。订单号在工单中作为唯一业务键使用。
    /// </summary>
    public WorkOrderSummaryViewModel FindTicketByOrderId(string orderId)
    {
        if (string.IsNullOrWhiteSpace(orderId))
            return null;

        var target = orderId.Trim();
        return Tickets.FirstOrDefault(ticket =>
            string.Equals(ticket.WechatOrderId, target, StringComparison.Ordinal));
    }

    public void Dispose()
    {
        if (_disposed)
            return;
        SaveWorkOrderList();
        _disposed = true;
		ClearPendingAttachments();
        _ticketService.NotificationReceived -= OnNotificationReceived;
        _ticketService.StateChanged -= OnRealtimeStateChanged;
        _ticketService.Dispose();
    }

    private void OpenNewDraft()
    {
        if (SelectedOrder == null)
        {
            SetNotice("未提供关联订单，无法新建工单。", true);
            return;
        }

        IsDraft = true;
        SelectedTicket = null;
        Messages.Clear();
        ClearPendingAttachments();
        HasMoreMessages = false;
        _nextBefore = null;
        DraftText = string.Empty;
        _pendingCreateFingerprint = null;
        _pendingCreateRequestId = null;
        ClearNotice();
    }

    /// <summary>
    /// 取消未提交的新工单。点击其他工单或开始搜索时会调用。
    /// </summary>
    private void CancelDraft()
    {
        if (!IsDraft)
            return;

        IsDraft = false;
        SelectedOrder = null;
        DraftText = string.Empty;
        ClearPendingAttachments();
        _pendingCreateFingerprint = null;
        _pendingCreateRequestId = null;
        ClearNotice();
    }

    private async Task SelectPendingTicketAsync()
    {
        var key = _pendingOpenKey;
        if (string.IsNullOrWhiteSpace(key) || IsBusy)
            return;

        try
        {
            _pendingOpenKey = null;
            var ticket = FindTicket(key);
            if (ticket == null)
            {
                var parts = key.Split(new[] { '|' }, 2);
                if (parts.Length != 2)
                    return;
                await RefreshSingleWorkOrderAsync(parts[0], parts[1]);
                ticket = FindTicket(key);
            }

            if (ticket != null)
            {
                IsDraft = false;
                await SelectTicketAsync(ticket);
            }
        }
        catch (Exception ex)
        {
            SetNotice("打开指定工单失败：" + DescribeException(ex), true);
        }
    }

    private async Task SelectTicketAsync(WorkOrderSummaryViewModel ticket)
    {
        if (ticket == null || IsBusy)
            return;

        TicketSearchText = string.Empty;
        CancelDraft();
        ClearPendingAttachments();
        ApplyKnownProductInfo(ticket);
        SelectedTicket = ticket;
        await LoadMessagesAsync(ticket, replace: true);
    }

    private async Task CreateTicketAsync()
    {
        if (!CanCreateTicket())
            return;

        var description = (DraftText ?? string.Empty).Trim();
        var fingerprint = SelectedOrder.OrderKey + "|" + description;
        if (!string.Equals(
            fingerprint,
            _pendingCreateFingerprint,
            StringComparison.Ordinal))
        {
            _pendingCreateFingerprint = fingerprint;
            _pendingCreateRequestId = NewOperationId("create");
        }

        IsBusy = true;
        ClearNotice();
        try
        {
            var result = await _ticketService.CreateWorkOrderAsync(
                _options,
                SelectedOrder,
                description,
                null);

            var operation = (result.Operation ?? string.Empty).ToLowerInvariant();
            var isExisting = operation == "existing";

            var targetKey = result.AppId + "|" + result.WechatOrderId;
            if (isExisting)
            {
                ChatText = description;
                SetNotice(
                    "该订单已有未完结工单，服务端未重复追加描述。已打开原工单，请点击“发送”提交本次补充。",
                    false);
            }
            else if (operation == "reopened")
            {
                SetNotice("原工单已重新开启，本次问题已加入留言板。", false);
            }
            else
            {
                SetNotice("工单已提交，等待客服回复。", false);
            }

            _pendingCreateFingerprint = null;
            _pendingCreateRequestId = null;
            DraftText = string.Empty;
            IsDraft = false;
            await RefreshAllWorkOrdersAsync(
                loadSelectedMessages: false,
                preferredKey: targetKey);
            var target = Tickets.FirstOrDefault(t =>
                string.Equals(t.Key, targetKey, StringComparison.Ordinal));
            if (target != null)
            {
                SelectedTicket = target;
                await LoadMessagesAsync(target, replace: true);
            }
        }
        catch (Exception ex)
        {
            SetNotice(DescribeException(ex), true);
        }
        finally
        {
            IsBusy = false;
        }
    }

    private async Task SendMessageAsync()
    {
        if (!CanSendMessage())
            return;

        var ticket = SelectedTicket;
        var text = (ChatText ?? string.Empty).Trim();
        var pendingAttachments = PendingAttachments.ToList();
        var attachmentFingerprint = string.Join(
            "|",
            pendingAttachments.Select(item => item.Fingerprint));
        var fingerprint = ticket.Key + "|" + text + "|" + attachmentFingerprint;
        if (!string.Equals(
            fingerprint,
            _pendingMessageFingerprint,
            StringComparison.Ordinal))
        {
            _pendingMessageFingerprint = fingerprint;
            _pendingMessageId = NewOperationId("send");
        }

        IsBusy = true;
        ClearNotice();
        try
        {
            var receipts = new List<MessageAttachmentReceipt>();
            for (var index = 0; index < pendingAttachments.Count; index++)
            {
                var attachment = pendingAttachments[index];
                if (!attachment.HasReceipt)
                {
                    SetNotice(
                        "正在上传图片 "
                        + (index + 1)
                        + "/"
                        + pendingAttachments.Count
                        + "…",
                        false);
                    var uploadTicket =
                        await _ticketService.CreateImageUploadTicketAsync(
                            _options,
                            ticket.AppId,
                            ticket.WechatOrderId,
                            attachment.FileName,
                            attachment.MimeType,
                            attachment.ByteSize);
                    var receipt = await _ticketService.UploadImageAsync(
                        uploadTicket.Upload,
                        attachment.FilePath);
                    attachment.SetReceipt(receipt);
                }
                receipts.Add(attachment.Receipt);
            }

            if (pendingAttachments.Count > 0)
                SetNotice("正在发送留言…", false);

            var result = await _ticketService.SendMessageAsync(
                _options,
                ToSummaryDto(ticket),
                string.IsNullOrWhiteSpace(text) ? null : text,
                _pendingMessageId,
                receipts);

            if (result.Message != null)
            {
                RememberMessage(ticket.Key, result.Message);
                MergeMessages(new[] { result.Message });
            }
            ticket.ApplySendResult(result.Status, result.Version);
            MoveTicketToTop(ticket);
            TicketView.Refresh();
            ChatText = string.Empty;
            ClearPendingAttachments();
            SetNotice(
                result.Reopened
                    ? "留言已发送，已完结工单已重新开启。"
                    : (pendingAttachments.Count > 0
                        ? "图片已发送。"
                        : "留言已发送。"),
                false);
            await MarkReadBestEffortAsync(ticket);
            SaveWorkOrderList();
            MessageScrollVersion++;
        }
        catch (TicketApiException ex)
            when (ex.StatusCode == 410
                || string.Equals(
                    ex.ErrorCode,
                    "client_api_image_expired",
                    StringComparison.OrdinalIgnoreCase))
        {
            foreach (var attachment in PendingAttachments)
                attachment.ClearReceipt();
            _pendingMessageFingerprint = null;
            _pendingMessageId = null;
            SetNotice(
                "图片上传凭证已过期，已重置上传状态，请重新点击发送。",
                true);
        }
        catch (TicketApiException ex)
            when (ex.StatusCode == 409
                || string.Equals(
                    ex.ErrorCode,
                    "client_api_image_already_used",
                    StringComparison.OrdinalIgnoreCase))
        {
            foreach (var attachment in PendingAttachments)
                attachment.ClearReceipt();
            SetNotice("工单状态或图片回执发生冲突，正在刷新最新内容。", true);
            _pendingMessageFingerprint = null;
            _pendingMessageId = null;
            await RefreshAllWorkOrdersAsync(
                loadSelectedMessages: false,
                preferredKey: ticket.Key);
            var refreshed = Tickets.FirstOrDefault(t =>
                string.Equals(t.Key, ticket.Key, StringComparison.Ordinal));
            if (refreshed != null)
            {
                SelectedTicket = refreshed;
                await LoadMessagesAsync(refreshed, replace: true);
            }
        }
        catch (Exception ex)
        {
            SetNotice(DescribeException(ex), true);
        }
        finally
        {
            IsBusy = false;
        }
    }

    private async Task RefreshMessagesAsync()
    {
        var ticket = SelectedTicket;
        if (!_configured || IsBusy || IsLoadingMessages || IsDraft || ticket == null)
            return;

        var options = _options;
        IsBusy = true;
        IsLoadingMessages = true;
        ClearNotice();
        try
        {
            await FetchConversationAsync(ticket.AppId, ticket.WechatOrderId, force: true);
            if (_disposed || !ReferenceEquals(options, _options)
                || IsDraft || SelectedTicket?.Key != ticket.Key)
                return;
            ShowCachedConversation(SelectedTicket);
            await MarkReadBestEffortAsync(SelectedTicket);
        }
        catch (Exception ex)
        {
            SetNotice("刷新工单消息失败：" + DescribeException(ex), true);
        }
        finally
        {
            IsLoadingMessages = false;
            IsBusy = false;
        }
    }

    private async Task LoadEarlierMessagesAsync()
    {
        var ticket = SelectedTicket;
        if (ticket == null || !HasMoreMessages || string.IsNullOrWhiteSpace(_nextBefore))
            return;

        IsBusy = true;
        try
        {
            var response = await _ticketService.GetMessagesAsync(
                _options,
                ticket.AppId,
                ticket.WechatOrderId,
                _nextBefore,
                50);
            foreach (var message in response.Items ?? new List<TicketMessageDto>())
                RememberMessage(ticket.Key, message);
            _conversationPages[ticket.Key] = response;
            MergeMessages(response.Items ?? new List<TicketMessageDto>());
            HasMoreMessages = response.HasMore;
            _nextBefore = response.NextBefore;
        }
        catch (Exception ex)
        {
            SetNotice(DescribeException(ex), true);
        }
        finally
        {
            IsBusy = false;
        }
    }

    private async Task RestartRealtimeAsync()
    {
        if (!_configured)
            return;

        IsBusy = true;
        try
        {
            await _ticketService.RestartRealtimeAsync(_options);
            await RefreshAllWorkOrdersAsync(loadSelectedMessages: false);
            if (SelectedTicket != null && !IsDraft)
                await LoadMessagesAsync(SelectedTicket, replace: true);
            ClearNotice();
        }
        catch (Exception ex)
        {
            SetNotice(DescribeException(ex), true);
        }
        finally
        {
            IsBusy = false;
        }
    }

    private async Task LoadMessagesAsync(
        WorkOrderSummaryViewModel ticket,
        bool replace)
    {
        var version = ++_selectionVersion;
        IsLoadingMessages = true;
        try
        {
            // 点击工单始终可读取历史，Realtime 模式复用已加载的会话。
            if (!IsRealtimeConversation || !_conversationMessages.ContainsKey(ticket.Key))
                await FetchConversationAsync(ticket.AppId, ticket.WechatOrderId, force: !IsRealtimeConversation);
            if (version != _selectionVersion || SelectedTicket?.Key != ticket.Key || IsDraft)
                return;
            ShowCachedConversation(ticket);
            await MarkReadBestEffortAsync(ticket);
        }
        catch (Exception ex)
        {
            if (version == _selectionVersion)
            {
                if (replace) Messages.Clear();
                HasMoreMessages = false;
                _nextBefore = null;
                SetNotice(DescribeException(ex), true);
            }
        }
        finally
        {
            if (version == _selectionVersion)
                IsLoadingMessages = false;
        }
    }

    private async Task FetchConversationAsync(string appId, string orderId, bool force = false)
    {
        var key = appId + "|" + orderId;
        if (_conversationLoads.TryGetValue(key, out var loading))
        {
            await loading;
            if (!force) return;
        }
        var task = FetchConversationCoreAsync(appId, orderId);
        _conversationLoads[key] = task;
        try { await task; }
        finally
        {
            if (_conversationLoads.TryGetValue(key, out var current) && ReferenceEquals(current, task))
                _conversationLoads.Remove(key);
        }
    }

    private async Task FetchConversationCoreAsync(string appId, string orderId)
    {
        var options = _options;
        var key = appId + "|" + orderId;
        var before = _conversationMessages.TryGetValue(key, out var existing)
            ? new Dictionary<string, TicketMessageDto>(existing, StringComparer.Ordinal) : null;
        var response = await _ticketService.GetMessagesAsync(options, appId, orderId, null, 50);
        if (_disposed || !ReferenceEquals(options, _options)) return;
        // 刷新历史期间收到的增量不能被较早的接口快照覆盖。
        var addedDuringLoad = before != null && _conversationMessages.TryGetValue(key, out var latest)
            ? latest.Where(pair => !before.TryGetValue(pair.Key, out var old)
                || !ReferenceEquals(old, pair.Value)).Select(pair => pair.Value).ToList()
            : new List<TicketMessageDto>();
        // 只在历史请求成功后建立缓存；首次推送触发的历史已包含该消息，不再追加。
        _conversationMessages[key] = new Dictionary<string, TicketMessageDto>(StringComparer.Ordinal);
        foreach (var message in response.Items ?? new List<TicketMessageDto>())
            RememberMessage(key, message);
        foreach (var message in addedDuringLoad)
            RememberMessage(key, message);
        _conversationPages[key] = response;
    }

    private void ShowCachedConversation(WorkOrderSummaryViewModel ticket)
    {
        Messages.Clear();
        if (_conversationMessages.TryGetValue(ticket.Key, out var cached))
            MergeMessages(cached.Values);
        _conversationPages.TryGetValue(ticket.Key, out var page);
        HasMoreMessages = page?.HasMore ?? false;
        _nextBefore = page?.NextBefore;
        MessageScrollVersion++;
    }

    private async Task RefreshAllWorkOrdersAsync(
        bool loadSelectedMessages,
        string preferredKey = null)
    {
        IsLoading = true;
        try
        {
            var incoming = new List<WorkOrderSummaryDto>();
            string cursor = null;
            var page = 0;
            do
            {
                var response = await _ticketService.GetWorkOrdersAsync(
                    _options,
                    limit: 100,
                    cursor: cursor);
                incoming.AddRange(response.Items ?? new List<WorkOrderSummaryDto>());
                cursor = response.NextCursor;
                page++;
                if (!response.HasMore || string.IsNullOrWhiteSpace(cursor))
                    break;
            }
            while (page < 20);

            var currentKey = SelectedTicket?.Key;
            var existing = Tickets.ToDictionary(t => t.Key, StringComparer.Ordinal);
            var merged = new List<WorkOrderSummaryViewModel>();
            foreach (var dto in incoming)
            {
                if (dto == null || string.IsNullOrWhiteSpace(dto.AppId)
                    || string.IsNullOrWhiteSpace(dto.WechatOrderId))
                {
                    continue;
                }
                var key = dto.AppId + "|" + dto.WechatOrderId;
                var hasNewMessage = HasNewMessage(dto);
                if (existing.TryGetValue(key, out var item))
                {
                    // 查询期间可能先收到更新的 SSE，保留较新摘要，不能丢掉该工单。
                    item.TryApply(dto);
                }
                else
                {
                    item = new WorkOrderSummaryViewModel(dto);
                }
                if (hasNewMessage)
                    item.MarkHasNewMessage();
                ApplyKnownProductInfo(item);
                if (merged.All(t => !string.Equals(t.Key, item.Key, StringComparison.Ordinal)))
                    merged.Add(item);
            }

            Tickets.Clear();
            foreach (var item in merged.OrderByDescending(t => t.UpdatedAt))
                Tickets.Add(item);

            var target = FindTicket(preferredKey)
                ?? FindTicket(currentKey)
                ?? Tickets.FirstOrDefault();
            if (!IsDraft)
                SelectedTicket = target;

            SaveWorkOrderList();

            if (loadSelectedMessages && SelectedTicket != null && !IsDraft)
            {
                var selected = SelectedTicket;
                await FetchConversationAsync(selected.AppId, selected.WechatOrderId, force: true);
                if (!IsDraft && SelectedTicket?.Key == selected.Key)
                {
                    ShowCachedConversation(selected);
                    await MarkReadBestEffortAsync(selected);
                }
            }
        }
        catch (Exception ex)
        {
            SetNotice(DescribeException(ex), true);
        }
        finally
        {
            IsLoading = false;
        }
    }

    private async Task RefreshSingleWorkOrderAsync(string appId, string wechatOrderId)
    {
        if (string.IsNullOrWhiteSpace(appId) || string.IsNullOrWhiteSpace(wechatOrderId))
            return;

        var options = CloneOptions(_options);
        options.AppIds = new List<string> { appId };
        var response = await _ticketService.GetWorkOrdersAsync(
            options,
            wechatOrderId,
            limit: 1);
        var dto = response.Items?.FirstOrDefault();
        if (dto == null)
            return;

        var key = dto.AppId + "|" + dto.WechatOrderId;
        var hasNewMessage = HasNewMessage(dto);
        var existing = FindTicket(key);
        if (existing == null)
        {
            existing = new WorkOrderSummaryViewModel(dto);
            Tickets.Add(existing);
        }
        else if (!existing.TryApply(dto))
        {
            return;
        }

        if (hasNewMessage)
            existing.MarkHasNewMessage();
        ApplyKnownProductInfo(existing);
        SaveWorkOrderList();
        ReorderTickets();
        TicketView.Refresh();
        if (SelectedTicket != null
            && string.Equals(SelectedTicket.Key, key, StringComparison.Ordinal)
            && !IsDraft)
        {
            await LoadMessagesAsync(SelectedTicket, replace: true);
        }
    }

    private void MergeMessages(IEnumerable<TicketMessageDto> items)
    {
        var byId = Messages
            .GroupBy(m => m.MessageId)
            .ToDictionary(g => g.Key, g => g.First(), StringComparer.Ordinal);
        foreach (var dto in items)
        {
            if (dto == null)
                continue;
            var id = dto.MessageId;
            if (string.IsNullOrWhiteSpace(id))
                id = "sequence:" + dto.SequenceNo;
            if (byId.TryGetValue(id, out var existing))
                existing.UpdateFrom(dto);
            else
                byId[id] = new ChatMessageViewModel(dto);
        }

        var ordered = byId.Values
            .OrderBy(m => m.SequenceNo)
            .ThenBy(m => m.CreatedAt)
            .ToList();
        Messages.Clear();
        foreach (var message in ordered)
            Messages.Add(message);
    }

    private async Task MarkReadBestEffortAsync(WorkOrderSummaryViewModel ticket)
    {
        if (!_isWindowActive || ticket == null)
            return;

        var maxSequence = Messages.Count == 0
            ? 0
            : Messages.Max(m => m.SequenceNo);
        if (maxSequence <= 0)
            return;
        if (_lastReadSequences.TryGetValue(ticket.Key, out var lastRead)
            && maxSequence <= lastRead)
        {
            MarkTicketRead(ticket);
            return;
        }

        try
        {
            await _ticketService.MarkReadAsync(
                _options,
                ticket.AppId,
                ticket.WechatOrderId,
                maxSequence);
            if (!_isWindowActive)
                return;
            _lastReadSequences[ticket.Key] = maxSequence;
            MarkTicketRead(ticket);
            SaveWorkOrderList();
        }
        catch
        {
            // 已读失败不影响留言展示；下次打开工单会重新尝试。
        }
    }

    private async Task MarkSelectedTicketReadAsync()
    {
        var ticket = SelectedTicket;
        if (ticket == null || IsDraft)
            return;
        await MarkReadBestEffortAsync(ticket);
    }

    private static void MarkTicketRead(WorkOrderSummaryViewModel ticket)
    {
        ticket.MarkRead();
        TicketRealtimeMonitor.Current.MarkRead(
            ticket.AppId,
            ticket.WechatOrderId);
    }

    private void OnNotificationReceived(
        object sender,
        TicketRealtimeNotificationEventArgs args)
    {
        var notification = args?.Notification;
        if (notification == null)
            return;

        _dispatcher.BeginInvoke(new Action(() =>
        {
            _ = HandleNotificationAsync(notification);
        }));
    }

    private async Task HandleNotificationAsync(TicketRealtimeNotification notification)
    {
        if (_disposed || !_configured)
            return;

        if (!string.IsNullOrWhiteSpace(notification.EventId))
        {
            if (!_seenEventIds.Add(notification.EventId))
                return;
            if (_seenEventIds.Count > 5000)
                _seenEventIds.Clear();
        }

        try
        {
            if (notification.IsResyncRequired
                || string.Equals(notification.Type, "relay.ticket.created", StringComparison.OrdinalIgnoreCase))
            {
                // 刷新后仍恢复当前工单，不能自动切换到新工单。
                await RefreshAllWorkOrdersAsync(loadSelectedMessages: true);
                var created = FindTicket(notification.AppId + "|" + notification.WechatOrderId);
                if (created != null && !notification.IsResyncRequired) MoveTicketToTop(created);
                return;
            }
            if (string.IsNullOrWhiteSpace(notification.AppId)
                || string.IsNullOrWhiteSpace(notification.WechatOrderId)
                || !_options.AppIds.Contains(notification.AppId)) return;

            if (IsRealtimeConversation)
                await ApplyRealtimeNotificationAsync(notification);
            else
            {
                // History 保持原有查询摘要、刷新当前对话的流程。
                var ticket = FindTicket(notification.AppId + "|" + notification.WechatOrderId);
                var unreadCount = (ticket?.UnreadCount ?? 0) + 1;
                ticket?.EnsureUnreadCount(unreadCount);
                await RefreshSingleWorkOrderAsync(notification.AppId, notification.WechatOrderId);
                ticket = FindTicket(notification.AppId + "|" + notification.WechatOrderId);
                if (ticket != null && (SelectedTicket?.Key != ticket.Key || !_isWindowActive))
                    ticket.EnsureUnreadCount(unreadCount);
                SaveWorkOrderList();
            }
        }
        catch (Exception ex)
        {
            SetNotice("实时通知已收到，但刷新工单失败：" + DescribeException(ex), true);
        }
    }

    private void RememberMessage(string key, TicketMessageDto message, bool preserveExisting = false)
    {
        if (message == null)
            return;
        if (!_conversationMessages.TryGetValue(key, out var messages))
            _conversationMessages[key] = messages = new Dictionary<string, TicketMessageDto>(StringComparer.Ordinal);
        var id = string.IsNullOrWhiteSpace(message.MessageId)
            ? "sequence:" + message.SequenceNo : message.MessageId;
        if (!preserveExisting || !messages.ContainsKey(id))
            messages[id] = message;
    }

    private async Task ApplyRealtimeNotificationAsync(TicketRealtimeNotification notification)
    {
        var key = notification.AppId + "|" + notification.WechatOrderId;
        var ticket = FindTicket(key);
        // 未加载过会话：获取历史，推送消息不再额外插入。
        if (!_conversationMessages.TryGetValue(key, out var cached))
        {
            await FetchConversationAsync(notification.AppId, notification.WechatOrderId);
            ticket?.MarkHasNewMessage();
            if (!IsDraft && SelectedTicket?.Key == key)
            {
                ShowCachedConversation(SelectedTicket);
                await MarkReadBestEffortAsync(SelectedTicket);
            }
            SaveWorkOrderList();
            return;
        }
        var message = notification.Message;
        if (message == null) return;
        var id = string.IsNullOrWhiteSpace(message.MessageId) ? "sequence:" + message.SequenceNo : message.MessageId;
        var isNew = !cached.ContainsKey(id);
        RememberMessage(key, message);
        if (notification.Ticket != null && ticket != null)
        {
            var dto = notification.Ticket;
            dto.AppId = notification.AppId;
            dto.WechatOrderId = notification.WechatOrderId;
            dto.Version = dto.Version ?? notification.Version;
            dto.LastMessageAt = message.CreatedAt;
            dto.LastSenderType = message.SenderType;
            dto.UnreadCount = ticket.UnreadCount;
            ticket.TryApply(dto);
        }
        if (isNew) ticket?.IncrementUnreadCount();
        if (!IsDraft && SelectedTicket?.Key == key)
        {
            var existing = Messages.FirstOrDefault(m => m.MessageId == id);
            if (existing != null) existing.UpdateFrom(message);
            else Messages.Add(new ChatMessageViewModel(message));
            MessageScrollVersion++;
            await MarkReadBestEffortAsync(SelectedTicket);
        }
        TicketView.Refresh();
        SaveWorkOrderList();
    }

    private void OnRealtimeStateChanged(
        object sender,
        TicketRealtimeStateChangedEventArgs args)
    {
        _dispatcher.BeginInvoke(new Action(() =>
        {
            if (_disposed || args == null)
                return;
            SseState = args.State;
            SseStatusText = GetRealtimeStatusText(args.State);
        }));
    }

    private static string GetRealtimeStatusText(TicketRealtimeState state)
    {
        return state switch
        {
            TicketRealtimeState.Connected => "实时推送：已连接",
            TicketRealtimeState.Connecting => "实时推送：连接中…",
            TicketRealtimeState.Reconnecting => "实时推送：重连中…",
            _ => "实时推送：已断开"
        };
    }

    private bool CanCreateTicket()
    {
        return !IsBusy
            && IsDraft
            && SelectedOrder != null
            && !string.IsNullOrWhiteSpace(DraftText)
            && DraftText.Trim().Length <= 2000;
    }

    private bool FilterTicket(object item)
    {
        if (!(item is WorkOrderSummaryViewModel ticket))
            return false;

        var expectedStatus = GetStatusFilter(SelectedTicketStatusIndex);
        if (expectedStatus != null
            && !string.Equals(ticket.Status, expectedStatus, StringComparison.OrdinalIgnoreCase))
        {
            return false;
        }

        var keyword = (TicketSearchText ?? string.Empty).Trim();
        if (keyword.Length == 0)
            return true;

        return ContainsIgnoreCase(ticket.WechatOrderId, keyword)
            || ContainsIgnoreCase(ticket.ShopName, keyword)
            || ContainsIgnoreCase(ticket.ProductName, keyword)
            || ContainsIgnoreCase(ticket.StatusText, keyword)
            || ContainsIgnoreCase(ticket.PreviewText, keyword);
    }

    private static string GetStatusFilter(int selectedIndex)
    {
        switch (selectedIndex)
        {
            case 1:
                return "waiting_reply";
            case 2:
                return "replied";
            case 3:
                return "completed";
            default:
                return null;
        }
    }

    private static bool ContainsIgnoreCase(string source, string keyword)
    {
        return !string.IsNullOrWhiteSpace(source)
            && source.IndexOf(keyword, StringComparison.OrdinalIgnoreCase) >= 0;
    }

    private bool CanSendMessage()
    {
        var text = (ChatText ?? string.Empty).Trim();
        return !IsBusy
            && SelectedTicket != null
            && (!string.IsNullOrWhiteSpace(text) || PendingAttachments.Count > 0)
            && text.Length <= 4000;
    }

    private void RaiseSendCanExecuteChanged()
    {
        _sendMessageCommand.RaiseCanExecuteChanged();
    }

    private void RaiseCreateCanExecuteChanged()
    {
        _createTicketCommand.RaiseCanExecuteChanged();
    }

    private void RaiseLoadEarlierCanExecuteChanged()
    {
        _loadEarlierMessagesCommand.RaiseCanExecuteChanged();
        _refreshMessagesCommand.RaiseCanExecuteChanged();
    }

    private void SetNotice(string text, bool isError)
    {
        NoticeText = text ?? string.Empty;
        IsNoticeError = isError;
    }

    private void ClearNotice()
    {
        NoticeText = string.Empty;
        IsNoticeError = false;
    }

    /// <summary>
    /// 记录订单商品信息，后续刷新工单列表时用于补齐列表和对话中的商品展示。
    /// </summary>
    private void RememberOrderInfo(TicketOrderOption order)
    {
        if (order == null
            || string.IsNullOrWhiteSpace(order.OrderId)
            || _options == null)
        {
            return;
        }

        if (_options.Orders == null)
            _options.Orders = new List<TicketOrderOption>();

        var existing = _options.Orders.FirstOrDefault(o =>
            o != null
            && string.Equals(o.OrderId, order.OrderId, StringComparison.Ordinal)
            && (string.IsNullOrWhiteSpace(o.AppId)
                || string.IsNullOrWhiteSpace(order.AppId)
                || string.Equals(o.AppId, order.AppId, StringComparison.Ordinal)));
        if (existing == null)
        {
            _options.Orders.Add(order);
            return;
        }

        if (!string.IsNullOrWhiteSpace(order.GoodsName))
            existing.GoodsName = order.GoodsName;
        if (!string.IsNullOrWhiteSpace(order.ImageUrl))
            existing.ImageUrl = order.ImageUrl;
        if (order.Amount > 0)
            existing.Amount = order.Amount;
        if (order.OrderedAt != default)
            existing.OrderedAt = order.OrderedAt;
    }

    /// <summary>
    /// 依次使用本地缓存、已注入订单和订单列表快照补齐工单商品信息。
    /// </summary>
    private void ApplyKnownProductInfo(WorkOrderSummaryViewModel ticket)
    {
        if (ticket == null)
            return;

        if (_savedWorkOrders.TryGetValue(ticket.WechatOrderId, out var saved)
            && saved != null)
        {
            ticket.ApplyProductInfo(
                saved.ProductName,
                saved.ProductImageUrl,
                saved.Amount);
        }

        var option = _options?.Orders?.FirstOrDefault(o =>
            o != null
            && string.Equals(o.OrderId, ticket.WechatOrderId, StringComparison.Ordinal)
            && (string.IsNullOrWhiteSpace(o.AppId)
                || string.Equals(o.AppId, ticket.AppId, StringComparison.Ordinal)));
        if (option != null)
        {
            ticket.ApplyProductInfo(
                option.GoodsName,
                option.ImageUrl,
                option.Amount);
        }

        if (!string.IsNullOrWhiteSpace(ticket.ProductName)
            && !string.IsNullOrWhiteSpace(ticket.ProductImageUrl)
            && ticket.ProductAmount.HasValue)
        {
            return;
        }

        var localOrder = FindLocalOrder(ticket.WechatOrderId);
        if (localOrder == null)
            return;

        var localOption = TicketOrderOption.FromWechatOrder(localOrder, ticket.AppId);
        if (localOption == null)
            return;

        ticket.ApplyProductInfo(
            localOption.GoodsName,
            localOption.ImageUrl,
            localOption.Amount);
        RememberOrderInfo(localOption);
    }

    /// <summary>
    /// 从已加载的订单列表快照中查找商品信息，订单列表仍在加载时返回 null。
    /// </summary>
    private static oms_wei_order_info FindLocalOrder(string orderId)
    {
        if (string.IsNullOrWhiteSpace(orderId))
            return null;

        try
        {
            var orders = GlobalConfig.lstOrder;
            if (orders == null || orders.Count == 0)
                return null;

            var snapshot = new oms_wei_order_info[orders.Count];
            orders.CopyTo(snapshot, 0);
            return snapshot.FirstOrDefault(o =>
                o != null
                && string.Equals(o.order_id, orderId, StringComparison.Ordinal));
        }
        catch
        {
            return null;
        }
    }

    private WorkOrderSummaryViewModel FindTicket(string key)
    {
        if (string.IsNullOrWhiteSpace(key))
            return null;
        return Tickets.FirstOrDefault(t =>
            string.Equals(t.Key, key, StringComparison.Ordinal));
    }

    private void MoveTicketToTop(WorkOrderSummaryViewModel ticket)
    {
        var index = Tickets.IndexOf(ticket);
        if (index > 0)
            Tickets.Move(index, 0);
    }

    private void ReorderTickets()
    {
        var ordered = Tickets.OrderByDescending(t => t.UpdatedAt).ToList();
        for (var target = 0; target < ordered.Count; target++)
        {
            var current = Tickets.IndexOf(ordered[target]);
            if (current != target)
                Tickets.Move(current, target);
        }
    }

    private static WorkOrderSummaryDto ToSummaryDto(WorkOrderSummaryViewModel ticket)
    {
        return new WorkOrderSummaryDto
        {
            AppId = ticket.AppId,
            WechatOrderId = ticket.WechatOrderId,
            Status = ticket.Status,
            Version = ticket.Version
        };
    }

    private void LoadSavedOrderTimes()
    {
        _savedWorkOrders.Clear();
        _hasSavedCache = false;
        if (string.IsNullOrWhiteSpace(_options?.UserName))
            return;

        var cache = _cacheService.Load(_options.UserName);
        if (cache?.Items == null)
            return;

        foreach (var saved in cache.Items)
        {
            if (saved == null
                || string.IsNullOrWhiteSpace(saved.OrderId))
            {
                continue;
            }

            _savedWorkOrders[saved.OrderId] = saved;
        }
        _hasSavedCache = true;
    }

    private void UpdateSavedWorkOrders()
    {
        _savedWorkOrders = Tickets
            .GroupBy(t => t.WechatOrderId, StringComparer.Ordinal)
            .ToDictionary(
                group => group.Key,
                group => ToCacheItem(group.First()),
                StringComparer.Ordinal);

        var newCount = Tickets.Count(ticket => ticket.HasNewMessage);
        HasNewData = newCount > 0;
        NewDataText = newCount > 0
            ? $"有 {newCount} 个工单有新数据"
            : string.Empty;
    }

    private void SaveWorkOrderList()
    {
        if (string.IsNullOrWhiteSpace(_options?.UserName))
            return;
        if (!_initialized && Tickets.Count == 0)
            return;

        UpdateSavedWorkOrders();
        var cache = new WorkOrderListCache
        {
            UserName = _options.UserName,
            Items = _savedWorkOrders.Values
                .OrderByDescending(item => item.LastMessageAt)
                .ToList()
        };

        try
        {
            _cacheService.Save(cache);
            _hasSavedCache = true;
        }
        catch
        {
            // 本地缓存写入失败不应影响工单接口和页面操作。
        }
    }

    private bool HasNewMessage(WorkOrderSummaryDto dto)
    {
        if (dto == null || string.IsNullOrWhiteSpace(dto.WechatOrderId))
            return false;
        if (!_savedWorkOrders.TryGetValue(dto.WechatOrderId, out var saved))
            return _hasSavedCache;

        return WorkOrderCacheService.ParseTimestamp(dto.LastMessageAt)
            > saved.LastMessageAt;
    }

    private static WorkOrderListCacheItem ToCacheItem(
        WorkOrderSummaryViewModel ticket)
    {
        return new WorkOrderListCacheItem
        {
            OrderId = ticket.WechatOrderId,
            LastMessageAt = ticket.LastMessageAt,
            ProductName = ticket.ProductName,
            ProductImageUrl = ticket.ProductImageUrl,
            Amount = ticket.ProductAmount
        };
    }


    private static string NewOperationId(string prefix)
    {
        return prefix
            + "-"
            + DateTime.UtcNow.ToString("yyyyMMddHHmmss")
            + "-"
            + Guid.NewGuid().ToString("N");
    }

    private static TicketClientOptions CloneOptions(TicketClientOptions options)
    {
        return options?.Clone() ?? new TicketClientOptions();
    }

    private static string DescribeException(Exception ex)
    {
        if (ex is TicketApiException apiException)
        {
            var hint = apiException.StatusCode switch
            {
                400 => "请求格式错误。",
                404 => "该 APPID 和订单下尚无工单。",
                409 => "数据版本、幂等编号或图片回执冲突。",
                410 => "图片上传凭证已过期。",
                413 => "请求内容超过大小限制。",
                422 => "参数、图片格式或订单归属校验失败。",
                429 => "请求过于频繁，请稍后重试。",
                503 => "工单服务暂未开启或数据库繁忙。",
                _ => null
            };
            return string.IsNullOrWhiteSpace(hint)
                ? apiException.Message
                : hint + " " + apiException.Message;
        }
        if (ex is TimeoutException)
            return ex.Message;
        if (ex is ArgumentException)
            return ex.Message;
        return "操作失败：" + ex.Message;
    }
}