using BBWY.Client.APIServices;
using BBWY.Client.Models;
using BBWY.Client.Views.Order;
using BBWY.Common.Extensions;
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.Threading.Tasks;
using System.Windows;
using System.Windows.Input;

namespace BBWY.Client.ViewModels
{
    public class OrderListViewModel : BaseVM, IDenpendency
    {
        private OrderService orderService;
        private StatisticsService statisticsService;
        private AfterOrderService afterOrderService;
        private ChoosePurchaseSchemeViewModel choosePurchaseSchemeViewModel;

        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;
        private GlobalContext globalContext;
        private bool? includeAfterOrder;
        private bool includeExceptionOrder;
        private decimal currentConditionsTotalProfit;
        private string searchServiceId;
        private long waitPurchaseOrderCount;
        private long exceptionOrderCount;

        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 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; }

        /// <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 OrderListViewModel(OrderService orderService, StatisticsService statisticsService, AfterOrderService afterOrderService, GlobalContext globalContext, ChoosePurchaseSchemeViewModel choosePurchaseSchemeViewModel)
        {
            random = new Random();
            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.AddDays(-6);
            ToDayOrderAchievement = new ToDayOrderAchievement();
            InitSearchParam();

            SetOrderStateCommand = new RelayCommand<OrderState?>(SetOrderState);
            SearchOrderCommand = new RelayCommand(() =>
            {
                PageIndex = 1;
                Task.Factory.StartNew(() => LoadOrder(1));  //手动点击查询订单
                Task.Factory.StartNew(() => LoadTodayAchievement(StartDate, EndDate));
            });
            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;
                Task.Factory.StartNew(() => LoadOrder(1));  //点击日期查询订单
                Task.Factory.StartNew(() => LoadTodayAchievement(StartDate, EndDate));
            });
            OrderPageIndexChangedCommand = new RelayCommand<PageArgs>(p =>
            {
                Task.Factory.StartNew(() => LoadOrder(p.PageIndex));
                Task.Factory.StartNew(() => LoadTodayAchievement(StartDate, EndDate));
            });
            DecodeConsigneeCommand = new RelayCommand<Order>(DecodeConsignee);
            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);
            SearchOrderCommand.Execute(null);
        }

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

        public override void Refresh()
        {
            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;
            }
            PageIndex = 1;
            OrderCount = 0;
        }

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

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

        public void SetIncludeAfterOrder()
        {
            InitSearchParam();
            IncludeAfterOrder = true;
            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;
            Task.Factory.StartNew(() => LoadOrder(1));
        }

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

            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);
            LoadOrderCount();
        }

        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,
                                                     globalContext.User.Shop.ShopId,
                                                     OnlyDF,
                                                     ExcludeSD,
                                                     ExcludeCanceled,
                                                     IncludeExceptionOrder);
            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)
        {
            var response = statisticsService.GetTodayAchievementStatistics(startTime, endTime);
            if (!response.Success)
                return;
            _ = response.Data.Map(ToDayOrderAchievement);
        }

        private void LoadOrderCount()
        {
            var response = statisticsService.GetOrderCountStatistics(globalContext.User.Shop.ShopId, StartDate, EndDate);
            if (!response.Success)
                return;
            WaitPurchaseOrderCount = response.Data.WaitPurchaseCount;
            ExceptionOrderCount = response.Data.ExceptionCount;
        }

        private void DecodeConsignee(Order order)
        {
            var plaintextMobile = string.Empty;
            var grab = new GrabJDMibole(order.Id);
            if (grab.ShowDialog() == true)
                plaintextMobile = grab.Tag.ToString();
            if (string.IsNullOrEmpty(plaintextMobile))
            {
                MessageBox.Show("未获取到手机号", "提示");
                return;
            }
            IsLoading = true;
            Task.Factory.StartNew(() => orderService.DecodeConsignee(order.Id, plaintextMobile)).ContinueWith(t =>
            {
                var response = t.Result;
                IsLoading = false;
                if (!response.Success)
                {
                    App.Current.Dispatcher.Invoke(() => MessageBox.Show(response.Msg, "解密失败"));
                    return;
                }
                order.Consignee.ContactName = response.Data.ContactName;
                order.Consignee.Address = response.Data.Address;
                order.Consignee.Mobile = response.Data.Mobile;
                order.Consignee.IsDecode = true;
            });
        }

        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, string.Empty, 0M, 0M);
                sd.Closed += Sd_Closed;
                sd.ShowDialog();
            }
            else if (storageType == StorageType.代发)
            {
                var chooseDFType = new ChooseDFType();
                if (chooseDFType.ShowDialog() != true)
                    return;

                if (chooseDFType.DFType == DFType.关联订单)
                {
                    var relationPurchaseOrder = new RelationPurchaseOrder(orderId, globalContext.User.Shop.PurchaseAccountList, 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;
            if (relationPurchaseOrder.DialogResult != true)
                return;
            var orderDropShippingList = relationPurchaseOrder.OrderDropShippingList;
            var orderId = relationPurchaseOrder.OrderId;
            IsLoading = true;
            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);
                        });

            //var relationPurchaseOrder = sender as RelationPurchaseOrder;
            //if (relationPurchaseOrder.DialogResult != true)
            //    return;
            //var orderDropShipping = relationPurchaseOrder.OrderDropShipping;
            //var relationPurchaseOrderSkuList = relationPurchaseOrder.RelationPurchaseOrderSkuList;
            //IsLoading = true;
            //Task.Factory.StartNew(() => orderService.RelationPurchaseOrder(orderDropShipping, relationPurchaseOrderSkuList, 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(orderDropShipping.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 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;
            IsLoading = true;
            Task.Factory.StartNew(() => orderService.SDCalculationCost(orderId,
                                                                       isSetStorageType,
                                                                       sdCommissionAmount,
                                                                       deliveryExpressFreight,
                                                                       sdType.Value,
                                                                       sdKey,
                                                                       sdPayChannel,
                                                                       sdPaybillNo,
                                                                       sdOperator,
                                                                       flag,
                                                                       venderRemark,
                                                                       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);
                        });
        }

        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.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.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;
                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);
                   });
            }
            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;
            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);
               });
        }

        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;
            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;
            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;
            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;
                }

                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));
            Task.Factory.StartNew(() => orderService.ExportOrderList(SearchOrderId,
                                                     StartDate,
                                                     EndDate,
                                                     OrderState,
                                                     SearchSku,
                                                     SearchProductNo,
                                                     SearchWaybill,
                                                     SearchContactName,
                                                     pageIndex,
                                                     pageSize,
                                                     globalContext.User.Shop.ShopId,
                                                     OnlyDF,
                                                     ExcludeSD,
                                                     ExcludeCanceled)).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;
            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;
            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);
        }
    }
}