using BBWY.Client.APIServices;
using BBWY.Client.Helpers;
using BBWY.Client.Models;
using BBWY.Client.Views.Order;
using BBWY.Common.Models;
using BBWY.Controls;
using GalaSoft.MvvmLight.Command;
using GalaSoft.MvvmLight.Messaging;
using Microsoft.Win32;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading;
using System.Windows.Input;
using System.Windows;
using BBWY.Common.Extensions;

namespace BBWY.Client.ViewModels.PackTask
{

    public partial class TaskListViewModel : BaseVM, IDenpendency
    {
        private OrderService orderService;
        private StatisticsService statisticsService;
        private AfterOrderService afterOrderService;
        private ChoosePurchaseSchemeViewModel choosePurchaseSchemeViewModel;
        private DongDongHelper dongdongHelper;
        private bool isLoading;

        private string searchOrderId;
        private DateTime startDate;
        private DateTime endDate;
        private int pageIndex = 1;
        private int pageSize = 10;
        private int orderCount;
        private OrderState? orderState;
        private string searchSku;
        private string searchProductId;
        private string searchProductNo;
        private string searchContactName;
        private string searchWaybill;
        private bool onlyDF;
        private bool excludeSD;
        private bool excludeCanceled;
        private bool onlyUnhandle;
        private Random random;
        public GlobalContext globalContext { get; set; }
        private bool? includeAfterOrder;
        private bool includeExceptionOrder;
        //private decimal currentConditionsTotalProfit;
        private string searchServiceId;
        private long waitPurchaseOrderCount;
        private long exceptionOrderCount;
        private long waitOutStoreCount;
        private long afterSaleOrderUnhandleCount;

        private long? queryShopId;
        private string querySDOperator;
        private bool isSDGroup;







        /// <summary>
        /// 需求方创建日期
        /// </summary>
        private DateTime createTime;

        /// <summary>
        /// 任务状态（已完成=0，未完成=1）
        /// </summary>
        private int taskStatus;

        /// <summary>
        /// 项目完成时间
        /// </summary>
        private DateTime endTime;

        /// <summary>
        /// 需求方团队id
        /// </summary>
        private string departmentId;

        /// <summary>
        /// 需求方店铺id
        /// </summary>
        private string shopId;

        /// <summary>
        /// 货号品名（手写上传）
        /// </summary>
        private string brandName;

        /// <summary>
        /// 对接人
        /// </summary>
        private string userId;

        /// <summary>
        /// skuid
        /// </summary>
        private string skuId;

        /// <summary>
        /// 采购Sku名称
        /// </summary>
        private string skuName;

        /// <summary>
        /// sku数量
        /// </summary>
        private int skuCount;

        /// <summary>
        /// 店铺Sku图链接
        /// </summary>
        private string shopSkuImage;

        /// <summary>
        /// 打包类型（单件=0，多件=1）
        /// </summary>
        private int packType;

        /// <summary>
        /// 落仓(本地仓=0，齐越仓=1，京东仓=2)
        /// </summary>
        private int positionType;

        /// <summary>
        /// 基础包装（快递袋=0，纸箱=1，麻袋=2）
        /// </summary>
        private int basicPack;

        /// <summary>
        /// 增量1()
        /// </summary>
        private int increment1;

        /// <summary>
        /// 增量2()
        /// </summary>
        private int increment2;

        /// <summary>
        /// 工序道数
        /// </summary>
        private int processCount;

        /// <summary>
        /// 到货情况(待收货=0，部分收货=1，已到货=2)
        /// </summary>
        private int availability;

        /// <summary>
        /// 条形码id
        /// </summary>
        private long barcodeId;

        /// <summary>
        /// 合格证
        /// </summary>
        private long certificateId;

        /// <summary>
        /// 合格证位置（外部包装=0，产品包装=1）
        /// </summary>
        private int certificatePosition;

        /// <summary>
        /// 箱子耗材（自带=0，4-13号纸箱=1-10，）
        /// </summary>
        private int boxConsumables;

        /// <summary>
        /// 配件数
        /// </summary>
        private int goodsNumber;

        /// <summary>
        /// 气泡纸耗材（长=0，宽=1）
        /// </summary>
        private int airConsumables;

        /// <summary>
        /// 注意事项（对接备注）
        /// </summary>
        private string markMessage;







        /// <summary>
        /// 主键
        /// </summary>
        public long Id { get; set; }

        /// <summary>
        /// 需求方创建日期
        /// </summary>
        public DateTime Createtime { get; set; }

        /// <summary>
        /// 任务状态（已完成=0，未完成=1）
        /// </summary>
        public int Taskstatus { get; set; }

        /// <summary>
        /// 项目完成时间
        /// </summary>
        public DateTime Endtime { get; set; }

        /// <summary>
        /// 需求方团队id
        /// </summary>
        public string Departmentid { get; set; }

        /// <summary>
        /// 需求方店铺id
        /// </summary>
        public string Shopid { get; set; }

        /// <summary>
        /// 货号品名（手写上传）
        /// </summary>
        public string Brandname { get; set; }

        /// <summary>
        /// 对接人
        /// </summary>
        public string Userid { get; set; }

        /// <summary>
        /// skuid
        /// </summary>
        public string Skuid { get; set; }

        /// <summary>
        /// 采购Sku名称
        /// </summary>
        public string Skuname { get; set; }

        /// <summary>
        /// sku数量
        /// </summary>
        public int Skucount { get; set; }

        /// <summary>
        /// 店铺Sku图链接
        /// </summary>
        public string Shopskuimage { get; set; }

        /// <summary>
        /// 打包类型（单件=0，多件=1）
        /// </summary>
        public int Packtype { get; set; }

        /// <summary>
        /// 落仓(本地仓=0，齐越仓=1，京东仓=2)
        /// </summary>
        public int Positiontype { get; set; }

        /// <summary>
        /// 基础包装（快递袋=0，纸箱=1，麻袋=2）
        /// </summary>
        public int Basicpack { get; set; }

        /// <summary>
        /// 增量1()
        /// </summary>
        public int Increment1 { get; set; }

        /// <summary>
        /// 增量2()
        /// </summary>
        public int Increment2 { get; set; }

        /// <summary>
        /// 工序道数
        /// </summary>
        public int Processcount { get; set; }

        /// <summary>
        /// 到货情况(待收货=0，部分收货=1，已到货=2)
        /// </summary>
        public int Availability { get; set; }

        /// <summary>
        /// 条形码id
        /// </summary>
        public long Barcodeid { get; set; }

        /// <summary>
        /// 合格证
        /// </summary>
        public long Certificateid { get; set; }

        /// <summary>
        /// 合格证位置（外部包装=0，产品包装=1）
        /// </summary>
        public int Certificateposition { get; set; }

        /// <summary>
        /// 箱子耗材（自带=0，4-13号纸箱=1-10，）
        /// </summary>
        public int Boxconsumables { get; set; }

        /// <summary>
        /// 配件数
        /// </summary>
        public int Goodsnumber { get; set; }

        /// <summary>
        /// 气泡纸耗材（长=0，宽=1）
        /// </summary>
        public int Airconsumables { get; set; }

        /// <summary>
        /// 注意事项（对接备注）
        /// </summary>
        public string Markmessage { get; set; }


        public IList<Order> OrderList { get; set; }

        public IList<AfterSaleOrder> AfterSaleOrderList { get; set; }

        public bool IsLoading { get => isLoading; set { Set(ref isLoading, value); } }

        public string SearchOrderId { get => searchOrderId; set { Set(ref searchOrderId, value); } }

        public DateTime StartDate { get => startDate; set { Set(ref startDate, value); } }

        public DateTime EndDate { get => endDate; set { Set(ref endDate, value); } }

        public int PageIndex { get => pageIndex; set { Set(ref pageIndex, value); } }

        public int PageSize { get => pageSize; set { Set(ref pageSize, value); } }

        public int OrderCount { get => orderCount; set { Set(ref orderCount, value); } }

        public OrderState? OrderState { get => orderState; private set { Set(ref orderState, value); } }

        public string SearchSku { get => searchSku; set { Set(ref searchSku, value); } }
        public string SearchProductId { get => searchProductId; set { Set(ref searchProductId, value); } }
        public string SearchProductNo { get => searchProductNo; set { Set(ref searchProductNo, value); } }
        public string SearchContactName { get => searchContactName; set { Set(ref searchContactName, value); } }
        public string SearchWaybill { get => searchWaybill; set { Set(ref searchWaybill, value); } }

        public bool OnlyDF { get => onlyDF; set { Set(ref onlyDF, value); } }
        public bool ExcludeSD { get => excludeSD; set { Set(ref excludeSD, value); } }
        public bool ExcludeCanceled { get => excludeCanceled; set { Set(ref excludeCanceled, value); } }

        public bool? IncludeAfterOrder { get => includeAfterOrder; set { Set(ref includeAfterOrder, value); } }
        public string SearchServiceId { get => searchServiceId; set { Set(ref searchServiceId, value); } }

        /// <summary>
        /// 仅显示未处理
        /// </summary>
        public bool OnlyUnhandle { get => onlyUnhandle; set { Set(ref onlyUnhandle, value); } }

        public ToDayOrderAchievement ToDayOrderAchievement { get; set; }

        public ICommand SetOrderStateCommand { get; set; }

        public ICommand SearchOrderCommand { get; set; }

        public ICommand SyncOrderCommand { get; set; }

        public ICommand ExportCommand { get; set; }

        public ICommand CopyTextCommand { get; set; }

        public ICommand CopyOrderWaybillCommand { get; set; }

        public ICommand SetSearchDateCommand { get; set; }

        public ICommand OrderPageIndexChangedCommand { get; set; }

        public ICommand DecodeConsigneeCommand { get; set; }

        public ICommand GetBuyerAccountCommand { get; set; }

        public ICommand ChooseStorageTypeCommand { get; set; }

        public ICommand EditCostCommand { get; set; }

        public ICommand OutStockCommand { get; set; }

        public ICommand EditVenderRemarkCommand { get; set; }

        public ICommand SetIncludeAfterOrderCommand { get; set; }

        public ICommand FindAfterSaleOrderCommand { get; set; }

        public ICommand EditAfterSaleOrderCommand { get; set; }

        public ICommand EditAfterSaleOrderRefundPurchaseAmountCommand { get; set; }

        public ICommand SetIncludeExceptionOrderCommand { get; set; }

        public ICommand OpenSkuDetailCommand { get; set; }

        /// <summary>
        /// 当前条件利润汇总
        /// </summary>
        //public decimal CurrentConditionsTotalProfit { get => currentConditionsTotalProfit; set { Set(ref currentConditionsTotalProfit, value); } }

        /// <summary>
        /// 是否包含异常订单
        /// </summary>
        public bool IncludeExceptionOrder { get => includeExceptionOrder; set { Set(ref includeExceptionOrder, value); } }

        public long WaitPurchaseOrderCount { get => waitPurchaseOrderCount; set { Set(ref waitPurchaseOrderCount, value); } }
        public long ExceptionOrderCount { get => exceptionOrderCount; set { Set(ref exceptionOrderCount, value); } }
        public long WaitOutStoreCount { get => waitOutStoreCount; set { Set(ref waitOutStoreCount, value); } }
        public long AfterSaleOrderUnhandleCount { get => afterSaleOrderUnhandleCount; set { Set(ref afterSaleOrderUnhandleCount, value); } }

        /// <summary>
        /// 是否为刷单组
        /// </summary>
        public bool IsSDGroup { get => isSDGroup; set { Set(ref isSDGroup, value); } }

        public TaskListViewModel(OrderService orderService, StatisticsService statisticsService, AfterOrderService afterOrderService, GlobalContext globalContext, ChoosePurchaseSchemeViewModel choosePurchaseSchemeViewModel, DongDongHelper dongdongHelper)
        {
            IsSDGroup = globalContext.User.TeamName == "刷单组";
            if (IsSDGroup)
            {
                querySDOperator = globalContext.User.Name;

            }
            else
            {
                queryShopId = globalContext.User.Shop.ShopId;
            }

            random = new Random();
            this.dongdongHelper = dongdongHelper;
            this.globalContext = globalContext;
            this.orderService = orderService;
            this.statisticsService = statisticsService;
            this.afterOrderService = afterOrderService;
            this.choosePurchaseSchemeViewModel = choosePurchaseSchemeViewModel;
            OrderList = new ObservableCollection<Order>();
            AfterSaleOrderList = new ObservableCollection<AfterSaleOrder>();
            EndDate = DateTime.Now;
            StartDate = DateTime.Now.Date;
            ToDayOrderAchievement = new ToDayOrderAchievement();
            InitSearchParam();
            SetOrderStateCommand = new RelayCommand<OrderState?>(SetOrderState);
            SearchOrderCommand = new RelayCommand(() =>
            {
                PageIndex = 1;
                System.Threading.Tasks.Task.Factory.StartNew(() => LoadOrder(1));  //手动点击查询订单
            });
            SyncOrderCommand = new RelayCommand(SyncOrder);
            CopyTextCommand = new RelayCommand<string>(s =>
            {
                try
                {
                    Clipboard.SetText(s);
                }
                catch (Exception ex)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine(ex);
                    Console.ResetColor();
                }
            }
            );
            CopyOrderWaybillCommand = new RelayCommand<Order>(o => Clipboard.SetText(o.WaybillNo));
            SetSearchDateCommand = new RelayCommand<int>(d =>
            {
                EndDate = d == 1 ? DateTime.Now.Date.AddDays(-1) : DateTime.Now;
                StartDate = DateTime.Now.Date.AddDays(d * -1);
                PageIndex = 1;
                System.Threading.Tasks.Task.Factory.StartNew(() => LoadOrder(1));  //点击日期查询订单
            });
            OrderPageIndexChangedCommand = new RelayCommand<PageArgs>(p =>
            {
                System.Threading.Tasks.Task.Factory.StartNew(() => LoadOrder(p.PageIndex));
            });
            //DecodeConsigneeCommand = new RelayCommand<Order>(DecodeConsignee);
            GetBuyerAccountCommand = new RelayCommand<Order>(GetBuyerAccount);
            ChooseStorageTypeCommand = new RelayCommand<object>(ChooseStorageType);
            EditCostCommand = new RelayCommand<Order>(EditCost);
            OutStockCommand = new RelayCommand<Order>((o) => OutStock(o));
            EditVenderRemarkCommand = new RelayCommand<Order>(EditVenderRemark);
            ExportCommand = new RelayCommand(Export);
            SetIncludeAfterOrderCommand = new RelayCommand(SetIncludeAfterOrder);
            SetIncludeExceptionOrderCommand = new RelayCommand(SetIncludeExceptionOrder);
            EditAfterSaleOrderCommand = new RelayCommand<AfterSaleOrder>(EditAfterSaleOrder);
            EditAfterSaleOrderRefundPurchaseAmountCommand = new RelayCommand<AfterSaleOrder>(EditAfterSaleOrderRefundPurchaseAmount);
            FindAfterSaleOrderCommand = new RelayCommand<object>(FindAfterSaleOrder);
            OpenSkuDetailCommand = new RelayCommand<object>(OpenSkuDetail);
            SearchOrderCommand.Execute(null);
        }

        private void InitSearchParam(bool isInitDate = false)
        {
            this.OrderState = null;
            SearchOrderId = string.Empty;
            SearchContactName = string.Empty;
            SearchProductNo = string.Empty;
            SearchSku = string.Empty;
            SearchProductId = string.Empty;
            SearchWaybill = string.Empty;
            if (isInitDate)
            {
                EndDate = DateTime.Now;
                StartDate = DateTime.Now.Date;
            }
            PageIndex = 1;
            IncludeAfterOrder = null;
            IncludeExceptionOrder = false;
        }

        public override void Refresh()
        {
            queryShopId = globalContext.User.Shop.ShopId;
            OrderList.Clear();
            if (ToDayOrderAchievement != null)
            {
                ToDayOrderAchievement.AdvCost = 0M;
                ToDayOrderAchievement.DeliveryExpressFreight = 0M;
                ToDayOrderAchievement.OrderCount = 0;
                ToDayOrderAchievement.Profit = 0;
                ToDayOrderAchievement.PurchaseAmount = 0;
                ToDayOrderAchievement.SaleAmount = 0;
                ToDayOrderAchievement.SaleAmount = 0M;
                ToDayOrderAchievement.EmployereCost = 0M;
                ToDayOrderAchievement.TaxCost = 0M;
                ToDayOrderAchievement.SdCost = 0M;
                ToDayOrderAchievement.PularizeEndDate = null;
                ToDayOrderAchievement.ShoppopularizeList.Clear();
            }
            PageIndex = 1;
            OrderCount = 0;
        }

        public void SetOrderState(OrderState? orderState)
        {
            InitSearchParam(orderState == null);
            this.OrderState = orderState;
            System.Threading.Tasks.Task.Factory.StartNew(() => LoadOrder(1));  //选择状态查询订单
        }

        private void SetIncludeExceptionOrder()
        {
            InitSearchParam();
            IncludeExceptionOrder = true;
            System.Threading.Tasks.Task.Factory.StartNew(() => LoadOrder(1));
        }

        public void SetIncludeAfterOrder()
        {
            InitSearchParam();
            IncludeAfterOrder = true;
            System.Threading.Tasks.Task.Factory.StartNew(() => LoadOrder(1));
        }

        public void SetIncludeAfterOrder(string orderId, string skuId, DateTime startDate, DateTime endDate)
        {
            InitSearchParam();
            SearchOrderId = orderId;
            SearchSku = skuId;
            StartDate = startDate;
            EndDate = endDate;
            IncludeAfterOrder = true;
            System.Threading.Tasks.Task.Factory.StartNew(() => LoadOrder(1));
        }

        public void RefreshOrder(string orderId, bool isRemoveOrder = false)
        {
            //Task.Factory.StartNew(() => LoadOrder(PageIndex));
            var order = OrderList.FirstOrDefault(o => o.Id == orderId);
            if (order == null)
            {
                IsLoading = false;
                return;
            }

            if (isRemoveOrder)
            {
                IsLoading = false;
                Application.Current.Dispatcher.Invoke(() =>
                {
                    OrderList.Remove(order);
                });
            }

            var orderResponse = orderService.GetOrderById(orderId);
            IsLoading = false;
            if (!orderResponse.Success)
            {
                Application.Current.Dispatcher.Invoke(() => MessageBox.Show(orderResponse.Msg, "查询订单详情"));
                return;
            }

            var newOrder = orderResponse.Data.Map<Order>();
            newOrder.LocalConvert();

            Application.Current.Dispatcher.Invoke(() =>
            {
                var orderIndex = OrderList.IndexOf(order);
                OrderList.Remove(order);
                OrderList.Insert(orderIndex, newOrder);
            });

        }

        public void RefreshAfterOrder(long afterSaleOrderId)
        {
            var afterSaleOrder = AfterSaleOrderList.FirstOrDefault(aso => aso.Id == afterSaleOrderId);
            if (afterSaleOrder == null)
            {
                IsLoading = false;
                return;
            }
            var afterSaleOrderResponse = afterOrderService.GetAfterSaleOrderById(afterSaleOrderId);
            IsLoading = false;
            if (!afterSaleOrderResponse.Success)
            {
                Application.Current.Dispatcher.Invoke(() => MessageBox.Show(afterSaleOrderResponse.Msg, "查询售后单"));
                return;
            }

            var newAfterSaleOrder = afterSaleOrderResponse.Data.Map<AfterSaleOrder>();
            App.Current.Dispatcher.Invoke(() =>
            {
                var index = AfterSaleOrderList.IndexOf(afterSaleOrder);
                AfterSaleOrderList.Remove(afterSaleOrder);
                AfterSaleOrderList.Insert(index, newAfterSaleOrder);
            });

        }

        private void LoadOrder(int pageIndex)
        {
            if (IncludeAfterOrder == true)
                LoadAfterSaleOrder(pageIndex);
            else
                LoadNormalOrder(pageIndex);

            if (!IsSDGroup)
            {
                System.Threading.Tasks.Task.Factory.StartNew(() => LoadTodayAchievement(StartDate, EndDate, queryShopId.Value));
                System.Threading.Tasks.Task.Factory.StartNew(() => LoadOrderCount(queryShopId.Value));
            }
            else
            {
           
            }
        }

        private void LoadNormalOrder(int pageIndex)
        {
            IsLoading = true;
            Thread.Sleep(random.Next(0, 1000));
            var response = orderService.GetOrderList(SearchOrderId,
                                                     StartDate,
                                                     EndDate,
                                                     OrderState,
                                                     SearchSku,
                                                     SearchProductId,
                                                     SearchProductNo,
                                                     SearchWaybill,
                                                     SearchContactName,
                                                     pageIndex,
                                                     pageSize,
                                                     queryShopId,
                                                     OnlyDF,
                                                     ExcludeSD,
                                                     ExcludeCanceled,
                                                     IncludeExceptionOrder,
                                                     querySDOperator);
            if (!response.Success)
            {
                IsLoading = false;
                App.Current.Dispatcher.Invoke(() => MessageBox.Show(response.Msg, "提示"));
                return;
            }
            OrderCount = response.Data.Count;
            //CurrentConditionsTotalProfit = response.Data.CurrentConditionsTotalProfit;
            var orderList = response.Data.Items.Map<IList<Order>>();
            App.Current.Dispatcher.Invoke(() =>
            {
                OrderList.Clear();
                foreach (var order in orderList)
                {
                    order.LocalConvert();
                    OrderList.Add(order);
                }

                Messenger.Default.Send(string.Empty, "OrderList_ScrollToTop");
            });
            IsLoading = false;
        }

        private void LoadAfterSaleOrder(int pageIndex)
        {
            IsLoading = true;
            Thread.Sleep(random.Next(0, 1000));
            var response = afterOrderService.GetAfterSaleOrderList(globalContext.User.Shop.ShopId,
                                                                   SearchOrderId,
                                                                   StartDate,
                                                                   EndDate,
                                                                   SearchProductId,
                                                                   SearchSku,
                                                                   SearchServiceId,
                                                                   OnlyUnhandle,
                                                                   pageIndex,
                                                                   pageSize);

            if (!response.Success)
            {
                IsLoading = false;
                App.Current.Dispatcher.Invoke(() => MessageBox.Show(response.Msg, "提示"));
                return;
            }

            OrderCount = response.Data.Count;
            var afterOrderList = response.Data.Items.Map<IList<AfterSaleOrder>>();
            App.Current.Dispatcher.Invoke(() =>
            {
                AfterSaleOrderList.Clear();
                foreach (var aso in afterOrderList)
                    AfterSaleOrderList.Add(aso);
                Messenger.Default.Send(string.Empty, "AfterSaleOrderList_ScrollToTop");
            });
            IsLoading = false;
        }

        private void LoadTodayAchievement(DateTime startTime, DateTime endTime, long shopId)
        {
            var response = statisticsService.GetTodayAchievementStatistics(startTime, endTime, shopId);
            if (!response.Success)
                return;
            ToDayOrderAchievement.AdvCost = response.Data.AdvCost;
            ToDayOrderAchievement.DeliveryExpressFreight = response.Data.DeliveryExpressFreight;
            ToDayOrderAchievement.EmployereCost = response.Data.EmployeeCost;
            ToDayOrderAchievement.PularizeEndDate = response.Data.PularizeEndDate;
            ToDayOrderAchievement.OrderCount = response.Data.OrderCount;
            ToDayOrderAchievement.PlatformCommissionAmount = response.Data.PlatformCommissionAmount;
            ToDayOrderAchievement.Profit = response.Data.Profit;
            ToDayOrderAchievement.ProfitRaito = response.Data.ProfitRaito;
            ToDayOrderAchievement.PurchaseAmount = response.Data.PurchaseAmount;
            ToDayOrderAchievement.SaleAmount = response.Data.SaleAmount;
            ToDayOrderAchievement.SdCost = response.Data.SDCost;
            ToDayOrderAchievement.TaxCost = response.Data.TaxCost;
            ToDayOrderAchievement.TotalCost = response.Data.TotalCost;

            App.Current.Dispatcher.Invoke(() =>
            {
                ToDayOrderAchievement.ShoppopularizeList.Clear();
                if (response.Data.ShoppopularizeList != null && response.Data.ShoppopularizeList.Count() > 0)
                {
                    foreach (var item in response.Data.ShoppopularizeList)
                        ToDayOrderAchievement.ShoppopularizeList.Add(item);
                }
            });
        }

        private void LoadOrderCount(long shopId)
        {
            var response = statisticsService.GetOrderCountStatistics(shopId);
            if (!response.Success)
                return;
            WaitPurchaseOrderCount = response.Data.WaitPurchaseCount;
            ExceptionOrderCount = response.Data.ExceptionCount;
            WaitOutStoreCount = response.Data.WaitOutStoreCount;
            AfterSaleOrderUnhandleCount = response.Data.AfterSaleOrderUnhandleCount;
        }

        private void GetBuyerAccount(Order order)
        {
            if (string.IsNullOrEmpty(order.BuyerAccount))
            {
                var buyerAccount = string.Empty;
                var grab = new GrabJDMibole(order.Id, globalContext.User.Shop.ShopId.ToString());
                if (grab.ShowDialog() == true)
                    buyerAccount = grab.Tag.ToString();
                if (string.IsNullOrEmpty(buyerAccount))
                {
                    MessageBox.Show("未获取到买家账号", "提示");
                    return;
                }
                order.BuyerAccount = buyerAccount;
            }

            //获取本机咚咚客服列表
            var currentMachineServiceGroupList = dongdongHelper.GetAllDongdongUser();
            if (currentMachineServiceGroupList == null || currentMachineServiceGroupList.Count() == 0)
            {
                MessageBox.Show("未获取到本机咚咚客服账号列表", "提示");
                return;
            }

            //匹配客服账号
            var waiter = currentMachineServiceGroupList.Intersect(globalContext.ShopServiceGroupList)?.FirstOrDefault();
            if (string.IsNullOrEmpty(waiter))
            {
                waiter = currentMachineServiceGroupList.Intersect(globalContext.ShopServiceGroupLowerList)?.FirstOrDefault();
                if (string.IsNullOrEmpty(waiter))
                {
                    MessageBox.Show("未匹配到当前店铺客服组和本机咚咚客服账号的交集", "提示");
                    return;
                }
            }

            //建立websocket连接


            //唤醒咚咚
            dongdongHelper.WakeUpDongDong(waiter, order.BuyerAccount);
        }

        private void ChooseStorageType(object param)
        {
            var paramList = (object[])param;
            var orderId = paramList[0].ToString();
            var storageType = (StorageType)paramList[1];

            var order = OrderList.FirstOrDefault(o => o.Id == orderId);
            if (order.StorageType == storageType)
                return;//忽略相同的仓储类型

            if (storageType == StorageType.本地自发)
            {
                var calculationCostType = new ChooseCalculationCostType(orderId, storageType, true);
                calculationCostType.Closed += ChooseCalculationCostType_Closed;
                calculationCostType.ShowDialog();
            }
            else if (storageType == StorageType.SD)
            {
                var sd = new SD(orderId, true, order.VenderRemark, order.Flag, string.Empty, null, string.Empty, globalContext.User.Name, 0M, 0M, 0M, IsSDGroup ? SDType.刷单组 : SDType.自刷);
                sd.Closed += Sd_Closed;
                sd.ShowDialog();
            }
            else if (storageType == StorageType.代发)
            {
                IsLoading = true;
                System.Threading.Tasks.Task.Factory.StartNew(() => statisticsService.GetSkuRecentSales(order.ItemList.Select(osku => osku.Id).ToList())).ContinueWith(t =>
                {
                    IsLoading = false;
                    if (t.Result.Success)
                    {
                        var tartgetSkus = t.Result.Data.Where(s => s.SaleCount >= 5).Select(s => s.SkuId).ToList();
                        if (tartgetSkus.Count() > 0)
                        {
                            bool? dialog = false;
                            App.Current.Dispatcher.Invoke(() =>
                            {
                                var confirmWindow = new SkuRecentSalesConfirmWindow(tartgetSkus);
                                dialog = confirmWindow.ShowDialog();
                            });
                            if (dialog != true)
                                return;
                        }
                    }

                    App.Current.Dispatcher.Invoke(() =>
                    {
                        var chooseDFType = new ChooseDFType();
                        if (chooseDFType.ShowDialog() != true)
                            return;

                        if (chooseDFType.DFType == DFType.关联订单)
                        {
                            var relationPurchaseOrder = new RelationPurchaseOrder(orderId, globalContext.User.Shop.PurchaseAccountList, null, null, order.ItemList.Select(osku => new RelationPurchaseOrderSku()
                            {
                                Logo = osku.Logo,
                                ProductId = osku.ProductId,
                                SkuId = osku.Id,
                                Quantity = osku.ItemTotal,
                                Title = osku.Title
                            }).ToList());
                            relationPurchaseOrder.Closed += RelationPurchaseOrder_Closed;
                            relationPurchaseOrder.ShowDialog();
                        }
                        else if (chooseDFType.DFType == DFType.在线采购)
                        {
                            choosePurchaseSchemeViewModel.SetData(order);
                            var choosePurchaseScheme = new ChoosePurchaseScheme();
                            choosePurchaseScheme.ShowDialog();
                        }
                    });
                });

            }
        }

        private void RelationPurchaseOrder_Closed(object sender, EventArgs e)
        {
            var relationPurchaseOrder = sender as RelationPurchaseOrder;
            var orderId = relationPurchaseOrder.OrderId;
            if (relationPurchaseOrder.IsRePurchase)
            {
                var order = OrderList.FirstOrDefault(o => o.Id == orderId);
                choosePurchaseSchemeViewModel.SetData(order);
                var choosePurchaseScheme = new ChoosePurchaseScheme();
                choosePurchaseScheme.ShowDialog();
                return;
            }
            if (relationPurchaseOrder.DialogResult != true)
                return;
            var orderDropShippingList = relationPurchaseOrder.OrderDropShippingList;
            IsLoading = true;
            System.Threading.Tasks.Task.Factory.StartNew(() => orderService.RelationPurchaseOrderV2(orderDropShippingList, globalContext.User.Shop.PlatformCommissionRatio ?? 0.05M))
                        .ContinueWith(t =>
                        {
                            var response = t.Result;
                            if (!response.Success)
                            {
                                IsLoading = false;
                                App.Current.Dispatcher.Invoke(() => MessageBox.Show(response.Msg, "关联采购订单"));
                                return;
                            }
                            RefreshOrder(orderId);
                        });
        }

        private void Sd_Closed(object sender, EventArgs e)
        {
            var sd = sender as SD;
            if (sd.DialogResult != true)
                return;
            var orderId = sd.OrderId;
            var isSetStorageType = sd.IsSetStorageType;
            var sdCommissionAmount = sd.SDCommissionAmount;
            var sdOrderAmount = sd.SDOrderAmount;
            var deliveryExpressFreight = sd.DeliveryExpressFreight;
            var sdType = sd.SDType;
            var flag = sd.Flag;
            var venderRemark = sd.VenderRemark;
            var sdKey = sd.SDKey;
            var sdPayChannel = sd.PayChannel;
            var sdPaybillNo = sd.SdPayBillNo;
            var sdOperator = sd.SdOperator;

            var shop = globalContext.User.Shop;


            IsLoading = true;
            System.Threading.Tasks.Task.Factory.StartNew(() => orderService.SDCalculationCost(orderId,
                                                                       isSetStorageType,
                                                                       sdCommissionAmount,
                                                                       sdOrderAmount,
                                                                       deliveryExpressFreight,
                                                                       sdType.Value,
                                                                       sdKey,
                                                                       sdPayChannel,
                                                                       sdPaybillNo,
                                                                       sdOperator,
                                                                       flag,
                                                                       venderRemark,
                                                                       shop))
                        .ContinueWith(r =>
                        {
                            var response = r.Result;
                            if (!response.Success)
                            {
                                IsLoading = false;
                                App.Current.Dispatcher.Invoke(() => MessageBox.Show(response.Msg, "SD成本"));
                                return;
                            }
                            //LoadOrder(PageIndex); //设置刷单刷新订单列表
                            var order = OrderList.FirstOrDefault(o => o.Id == orderId);
                            if (order != null && order.OrderState == Models.OrderState.待付款)
                            {
                                IsLoading = false;
                                App.Current.Dispatcher.Invoke(() =>
                                {
                                    OrderList.Remove(order);
                                    MessageBox.Show("已设置SD成本", "SD成本");
                                });
                            }
                            else
                            {
                                RefreshOrder(orderId);
                            }
                        });
        }

        private void EditCost(Order order)
        {
            if (order.StorageType == null)
                return;
            if (order.StorageType == StorageType.代发)
            {
                var relationPurchaseOrder = new RelationPurchaseOrder(order.Id, globalContext.User.Shop.PurchaseAccountList, order.OrderDropShippingList, order.HistoryOrderDropShippingList, order.ItemList.Select(osku => new RelationPurchaseOrderSku()
                {
                    Logo = osku.Logo,
                    ProductId = osku.ProductId,
                    SkuId = osku.Id,
                    Quantity = osku.ItemTotal,
                    Title = osku.Title,
                    SingleSkuAmount = (order.OrderCostDetailList.FirstOrDefault(ocd => ocd.SkuId == osku.Id)?.SkuAmount / osku.ItemTotal) ?? 0,
                    SingleSkuAmountStr = ((order.OrderCostDetailList.FirstOrDefault(ocd => ocd.SkuId == osku.Id)?.SkuAmount / osku.ItemTotal) ?? 0).ToString(),
                    OrderDropShippingId = osku.OrderDropShippingId
                }).ToList());
                relationPurchaseOrder.Closed += RelationPurchaseOrder_Closed;
                relationPurchaseOrder.ShowDialog();
            }
            else if (order.StorageType == StorageType.SD)
            {
                var sd = new SD(order.Id, false, order.VenderRemark, order.Flag, order.SDKey, order.SDPayChannel, order.SDPayBillNo, order.SDOperator, order.OrderCost.SDCommissionAmount, order.OrderCost.SDOrderAmount, order.OrderCost.DeliveryExpressFreight, order.SDType ?? SDType.自刷);
                sd.Closed += Sd_Closed;
                sd.ShowDialog();
            }
            else
            {
                var calculationCostType = new ChooseCalculationCostType(order.Id, order.StorageType.Value, false);
                calculationCostType.Closed += ChooseCalculationCostType_Closed;
                calculationCostType.ShowDialog();
            }
        }

        private void ChooseCalculationCostType_Closed(object sender, EventArgs e)
        {
            var chooseCalculationCostType = sender as ChooseCalculationCostType;
            chooseCalculationCostType.Closed -= ChooseCalculationCostType_Closed;
            if (chooseCalculationCostType.DialogResult != true)
                return;

            var orderId = chooseCalculationCostType.OrderId;
            var storageType = chooseCalculationCostType.StorageType;
            var isSetStorageType = chooseCalculationCostType.IsSetStorageType;
            var isAutoCalculation = chooseCalculationCostType.IsAutoCalculation;

            if (isAutoCalculation)
            {
                IsLoading = true;
                System.Threading.Tasks.Task.Factory.StartNew(() => orderService.AutoCalculationCost(orderId, isSetStorageType, storageType, globalContext.User.Shop.PlatformCommissionRatio ?? 0.05M)).ContinueWith(r =>
                {
                    var response = r.Result;
                    if (!response.Success)
                    {
                        IsLoading = false;
                        App.Current.Dispatcher.Invoke(() => MessageBox.Show(response.Msg, "自动计算成本"));
                        return;
                    }

                    //LoadOrder(PageIndex); //自动计算成功刷新订单列表
                    RefreshOrder(orderId, isSetStorageType);
                });
            }
            else
            {
                var order = OrderList.FirstOrDefault(o => o.Id == orderId);
                var orderSkuList = order.ItemList.Select(osku => new ManualEditCostOrderSku()
                {
                    Id = osku.Id,
                    ItemTotal = osku.ItemTotal,
                    Logo = osku.Logo,
                    Price = osku.Price,
                    Title = osku.Title,
                    ProductId = osku.ProductId,
                    ProductItemNum = osku.ProductItemNum
                }).ToList();
                foreach (var manualEditCostOrderSku in orderSkuList)
                {
                    var orderCostDetailList = order.OrderCostDetailGroupList?.FirstOrDefault(g => g.SkuId == manualEditCostOrderSku.Id)?.Items;
                    if (orderCostDetailList != null && orderCostDetailList.Count > 0)
                    {
                        manualEditCostOrderSku.ConsumableAmount = orderCostDetailList.Sum(ocd => ocd.ConsumableAmount);
                        manualEditCostOrderSku.DeliveryExpressFreight = orderCostDetailList.Sum(ocd => ocd.DeliveryExpressFreight);
                        manualEditCostOrderSku.FirstFreight = orderCostDetailList.Sum(ocd => ocd.FirstFreight);
                        //manualEditCostOrderSku.OperationAmount = orderCostDetailList.Sum(ocd => ocd.OperationAmount);
                        manualEditCostOrderSku.InStorageAmount = orderCostDetailList.Sum(ocd => ocd.InStorageAmount);
                        manualEditCostOrderSku.OutStorageAmount = orderCostDetailList.Sum(ocd => ocd.OutStorageAmount);
                        manualEditCostOrderSku.PurchaseFreight = orderCostDetailList.Sum(ocd => ocd.PurchaseFreight);
                        manualEditCostOrderSku.SkuAmount = orderCostDetailList.Sum(ocd => ocd.SkuAmount);
                        manualEditCostOrderSku.StorageAmount = orderCostDetailList.Sum(ocd => ocd.StorageAmount);
                        manualEditCostOrderSku.TotalCost = orderCostDetailList.Sum(ocd => ocd.TotalCost);
                        manualEditCostOrderSku.UnitCost = orderCostDetailList.FirstOrDefault().UnitCost;
                    }
                    manualEditCostOrderSku.ConsumableAmountStr = manualEditCostOrderSku.ConsumableAmount.ToString();
                    manualEditCostOrderSku.DeliveryExpressFreightStr = manualEditCostOrderSku.DeliveryExpressFreight.ToString();
                    manualEditCostOrderSku.FirstFreightStr = manualEditCostOrderSku.FirstFreight.ToString();
                    //manualEditCostOrderSku.OperationAmountStr = manualEditCostOrderSku.OperationAmount.ToString();
                    manualEditCostOrderSku.InStorageAmountStr = manualEditCostOrderSku.InStorageAmount.ToString();
                    manualEditCostOrderSku.OutStorageAmountStr = manualEditCostOrderSku.OutStorageAmount.ToString();
                    manualEditCostOrderSku.PurchaseFreightStr = manualEditCostOrderSku.PurchaseFreight.ToString();
                    manualEditCostOrderSku.SkuAmountStr = manualEditCostOrderSku.SkuAmount.ToString();
                    manualEditCostOrderSku.StorageAmountStr = manualEditCostOrderSku.StorageAmount.ToString();
                }

                var manualCalculationCost = new ManualCalculationCost(orderId, isSetStorageType, storageType, orderSkuList);
                manualCalculationCost.Closed += ManualCalculationCost_Closed;
                manualCalculationCost.ShowDialog();
            }
        }

        private void ManualCalculationCost_Closed(object sender, EventArgs e)
        {
            var manualCalculationCost = sender as ManualCalculationCost;
            manualCalculationCost.Closed -= ManualCalculationCost_Closed;
            if (manualCalculationCost.DialogResult != true)
                return;

            var orderId = manualCalculationCost.OrderId;
            var storageType = manualCalculationCost.StorageType;
            var isSetStorageType = manualCalculationCost.IsSetStorageType;
            var manualEditCostOrderSkuList = manualCalculationCost.ManualEditCostOrderSkuList;

            IsLoading = true;
            System.Threading.Tasks.Task.Factory.StartNew(() => orderService.ManualCalculationCost(orderId,
                                                                           isSetStorageType,
                                                                           storageType,
                                                                           manualEditCostOrderSkuList,
                                                                           globalContext.User.Shop.PlatformCommissionRatio ?? 0.05M)).ContinueWith(r =>
                                                                           {
                                                                               var response = r.Result;
                                                                               if (!response.Success)
                                                                               {
                                                                                   IsLoading = false;
                                                                                   App.Current.Dispatcher.Invoke(() => MessageBox.Show(response.Msg, "手动计算成本"));
                                                                                   return;
                                                                               }
                                                                               //LoadOrder(PageIndex); //手动计算成功刷新订单列表
                                                                               RefreshOrder(orderId, isSetStorageType);
                                                                           });
        }

        private void OutStock(Order o)
        {
            var outStock = new OutStock(o.Id, globalContext.LogisticsResponseList);
            outStock.Closed += OutStock_Closed;
            outStock.ShowDialog();
        }

        private void OutStock_Closed(object sender, EventArgs e)
        {
            var outStock = sender as OutStock;
            if (outStock.DialogResult != true)
                return;
            var orderId = outStock.OrderId;
            var waybillNo = outStock.WaybillNo;
            var logistics = outStock.SelectedLogistics;
            var order = OrderList.FirstOrDefault(o => o.Id == orderId);
            IsLoading = true;
            System.Threading.Tasks.Task.Factory.StartNew(() => orderService.OutStock(orderId, waybillNo, logistics.Id))
                        .ContinueWith(r =>
                        {
                            IsLoading = false;
                            var response = r.Result;
                            if (!response.Success)
                            {
                                App.Current.Dispatcher.Invoke(() => MessageBox.Show(response.Msg, "出库"));
                                return;
                            }
                            if (order != null)
                            {
                                order.OrderState = Models.OrderState.待收货;
                                order.WaybillNo = waybillNo;
                            }

                            //LoadOrder(PageIndex);
                        });
        }

        private void SyncOrder()
        {
            IsLoading = true;
            System.Threading.Tasks.Task.Factory.StartNew(() => orderService.SyncOrder(globalContext.User.Shop.ShopId, StartDate, EndDate)).ContinueWith(r =>
            {
                IsLoading = false;
                var response = r.Result;
                if (response.Success)
                    App.Current.Dispatcher.Invoke(() => MessageBox.Show("同步任务创建成功,该任务会执行一段时间,请稍后查询订单列表观察同步结果", "同步订单"));
                else
                    App.Current.Dispatcher.Invoke(() => MessageBox.Show(response.Msg, "同步订单"));
            });
        }

        private void EditVenderRemark(Order order)
        {
            var editWindow = new EditVenderRemark(order.Id, order.VenderRemark, order.Flag);
            editWindow.Closed += EditVenderRemarkWindow_Closed;
            editWindow.ShowDialog();
        }

        private void EditVenderRemarkWindow_Closed(object sender, EventArgs e)
        {
            var editWindow = sender as EditVenderRemark;
            if (editWindow.DialogResult != true)
                return;

            var orderId = editWindow.OrderId;
            var order = OrderList.FirstOrDefault(o => o.Id == orderId);
            if (order == null)
                return;
            var venderRemark = editWindow.VenderRemark;
            var flag = editWindow.Flag;

            IsLoading = true;
            System.Threading.Tasks.Task.Factory.StartNew(() => orderService.EditVenderRemark(orderId, venderRemark, flag)).ContinueWith(r =>
            {
                IsLoading = false;
                var response = r.Result;
                if (!response.Success)
                {
                    App.Current.Dispatcher.Invoke(() => MessageBox.Show(response.Msg, "修改商家备注"));
                    return;
                }
                if (OrderState == Models.OrderState.等待采购 && order.StorageType == StorageType.代发)
                {
                    App.Current.Dispatcher.Invoke(() => OrderList.Remove(order));
                    return;
                }
                order.VenderRemark = venderRemark;
                order.Flag = flag;
            });
        }

        private void Export()
        {
            var sfd = new SaveFileDialog() { Filter = "csv files(*.csv)|*.csv" };
            if (sfd.ShowDialog() != true)
                return;

            var ssaveFileName = sfd.FileName;
            IsLoading = true;
            Thread.Sleep(random.Next(500, 2000));
            System.Threading.Tasks.Task.Factory.StartNew(() => orderService.ExportOrderList(SearchOrderId,
                                                     StartDate,
                                                     EndDate,
                                                     OrderState,
                                                     SearchSku,
                                                     SearchProductNo,
                                                     SearchWaybill,
                                                     SearchContactName,
                                                     pageIndex,
                                                     pageSize,
                                                     queryShopId,
                                                     OnlyDF,
                                                     ExcludeSD,
                                                     ExcludeCanceled,
                                                     querySDOperator)).ContinueWith(t =>
                                                     {
                                                         var r = t.Result;
                                                         if (!r.Success)
                                                         {
                                                             IsLoading = false;
                                                             App.Current.Dispatcher.Invoke(() => MessageBox.Show(r.Msg, "导出"));
                                                             return;
                                                         }

                                                         try
                                                         {
                                                             var list = r.Data.Select(x => x.ToString()).ToList();
                                                             list.Insert(0, "日期,店铺订单号,SKU编码,订单状态,仓储类型,代发下单单号,售价,商品成本,采购运费,头程费用,仓储服务费,快递费,耗材费,入仓操作费,出仓操作费,刷单/空单号费,平台扣点,补差金额,应付金额,实收金额,利润,利润率,收件人联系方式,商家备注,售后类型,售后与特殊情况备注");
                                                             System.IO.File.WriteAllLines(ssaveFileName, list, Encoding.UTF8);
                                                             App.Current.Dispatcher.Invoke(() => MessageBox.Show("导出完成", "导出"));
                                                         }
                                                         catch (Exception ex)
                                                         {
                                                             App.Current.Dispatcher.Invoke(() => MessageBox.Show(r.Msg, "导出"));
                                                             return;
                                                         }
                                                         finally
                                                         {
                                                             IsLoading = false;
                                                         }
                                                     });
        }

        private void EditAfterSaleOrder(AfterSaleOrder afterSaleOrder)
        {
            var w = new EditAfterSaleOrderSku(afterSaleOrder);
            w.Closed += EditAfterSaleOrderSku_Closed;
            w.ShowDialog();
        }

        private void EditAfterSaleOrderSku_Closed(object sender, EventArgs e)
        {
            var w = sender as EditAfterSaleOrderSku;
            if (w.DialogResult != true)
                return;

            var afterSaleOrder = w.SaleOrder;
            IsLoading = true;
            System.Threading.Tasks.Task.Factory.StartNew(() => afterOrderService.EditAfterSaleOrder(afterSaleOrder.Id,
                                                                             afterSaleOrder.OrderId,
                                                                             afterSaleOrder.ProductResult.Value,
                                                                             afterSaleOrder.ServiceResult.Value,
                                                                             afterSaleOrder.ProductHealth.Value,
                                                                             afterSaleOrder.ReissueAfterSaleAmount,
                                                                             afterSaleOrder.ReissueFreight,
                                                                             afterSaleOrder.ReissueProductAmount,
                                                                             afterSaleOrder.SDRefundFreight)).ContinueWith(t =>
                                                                             {
                                                                                 var response = t.Result;
                                                                                 if (!response.Success)
                                                                                 {
                                                                                     IsLoading = false;
                                                                                     App.Current.Dispatcher.Invoke(() => MessageBox.Show(response.Msg, "修改售后"));
                                                                                     return;
                                                                                 }
                                                                                 RefreshAfterOrder(afterSaleOrder.Id);
                                                                             });
        }

        private void EditAfterSaleOrderRefundPurchaseAmount(AfterSaleOrder afterSaleOrder)
        {
            var w = new EditAfterSaleOrderRefundPurchaseAmount(afterSaleOrder);
            w.Closed += EditAfterSaleOrderRefundPurchaseAmount_Closed;
            w.ShowDialog();
        }

        private void EditAfterSaleOrderRefundPurchaseAmount_Closed(object sender, EventArgs e)
        {
            var w = sender as EditAfterSaleOrderRefundPurchaseAmount;
            if (w.DialogResult != true)
                return;

            var afterSaleOrder = w.SaleOrder;
            IsLoading = true;
            System.Threading.Tasks.Task.Factory.StartNew(() => afterOrderService.EditAfterSaleOrderRefundPurchaseAmount(afterSaleOrder.Id,
                                                                                                 afterSaleOrder.OrderId,
                                                                                                 afterSaleOrder.RefundPurchaseAmount.Value,
                                                                                                 afterSaleOrder.RefundMerchantOrderNo,
                                                                                                 afterSaleOrder.RefundAlipayOrderNo))
            .ContinueWith(t =>
            {
                var response = t.Result;
                if (!response.Success)
                {
                    IsLoading = false;
                    App.Current.Dispatcher.Invoke(() => MessageBox.Show(response.Msg, "修改采购退款"));
                    return;
                }
                RefreshAfterOrder(afterSaleOrder.Id);
            });
        }

        private void FindAfterSaleOrder(object param)
        {
            var paramList = (object[])param;
            var orderId = paramList[0].ToString();
            var skuId = paramList[1].ToString();
            var startDate = DateTime.Parse(paramList[2].ToString()).Date;
            var endDate = DateTime.Now.Date;
            SetIncludeAfterOrder(orderId, skuId, startDate, endDate);
        }

        private void OpenSkuDetail(object param)
        {
            var paramList = (object[])param;
            var orderId = paramList[0].ToString();
            var skuId = paramList[1].ToString();
            var order = OrderList.FirstOrDefault(o => o.Id == orderId);
            if (order.Platform == Platform.京东)
            {
                var url = $"https://item.jd.com/{skuId}.html";
                try
                {
                    System.Diagnostics.Process.Start("explorer.exe", url);
                }
                catch (Exception ex)
                {
                    Clipboard.SetText(url);
                    MessageBox.Show($"{ex.Message}\r\n调用浏览器失败,网页链接已复制到剪切板,请手动打开浏览器访问", "提示");
                }
            }
            else
            {

            }
        }
    }
}