using BBWY.Client.APIServices;
using BBWY.Client.APIServices.QiKu;
using BBWY.Client.Extensions;
using BBWY.Client.Helpers;
using BBWY.Client.Models;
using BBWY.Client.Models.PackUser;
using BBWY.Client.Views.BillCorrection;
using BBWY.Client.Views.PackerTask;
using BBWY.Client.Views.PackTask;
using BBWY.Client.Views.QualityTask;
using BBWY.Client.Views.SplitTask;
using BBWY.Client.Views.TaskOverTime;
using BBWY.Common.Models;
using BBWY.Controls;
using GalaSoft.MvvmLight.Command;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Net.Mail;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace BBWY.Client.ViewModels.PackerTask
{
    public class PackerTaskViewModel : BaseVM, IDenpendency
    {
        #region 属性

        private ObservableCollection<string> selectTitleList = new ObservableCollection<string> {
        "SKU名称","标题"
        };

        public ObservableCollection<string> SelectTitleList { get => selectTitleList; set { Set(ref selectTitleList, value); } }



        private ObservableCollection<string> selectExpressList = new ObservableCollection<string> {
        "物流单号","物流公司名称"
        };

        public ObservableCollection<string> SelectExpressList { get => selectExpressList; set { Set(ref selectExpressList, value); } }


        private ObservableCollection<string> selectSkuList = new ObservableCollection<string> {
        "SKU","SPU"
        };

        public ObservableCollection<string> SelectSkuList { get => selectSkuList; set { Set(ref selectSkuList, value); } }

        private ObservableCollection<string> selectIdList = new ObservableCollection<string> {
        "任务ID","拳探订单号"
        };
        public ObservableCollection<string> SelectIdList { get => selectIdList; set { Set(ref selectIdList, value); } }

        private ObservableCollection<string> selectShopList = new ObservableCollection<string> {
        "店铺","部门"
        };
        public ObservableCollection<string> SelectShopList { get => selectShopList; set { Set(ref selectShopList, value); } }
        private string waitPackCount;
        /// <summary>
        /// 待包装任务量
        /// </summary>
        public string WaitPackCount { get => waitPackCount; set { Set(ref waitPackCount, value); } }

        //private string packCompletedCount;

        //public string PackCompletedCount { get => packCompletedCount; set { Set(ref packCompletedCount, value); } }

        private PackTaskState? packTaskState;

        /// <summary>
        /// 任务包装状态
        /// </summary>
        public PackTaskState? PackTaskState { get => packTaskState; set { Set(ref packTaskState, value); } }


        private int pageIndex = 1;
        private int pageSize = 10;
        private int orderCount;//总数量

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

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

        public string searchDepartment;
        public string SearchDepartment
        {
            get => searchDepartment; set
            {
                Set(ref searchDepartment, value);

            }
        }


        public string searchSpuTitle;
        public string SearchSpuTitle
        {
            get => searchSpuTitle; set
            {
                Set(ref searchSpuTitle, value);

            }
        }

        public string searchSkuTitle;
        public string SearchSkuTitle
        {
            get => searchSkuTitle; set
            {
                Set(ref searchSkuTitle, value);

            }
        }
        /// <summary>
        /// 查询Sku
        /// </summary>
        private string searchSkuId;
        public string SearchSkuId { get => searchSkuId; set { Set(ref searchSkuId, value); } }

        /// <summary>
        /// 查询Spu
        /// </summary>
        private string searchSpuId;
        public string SearchSpuId { get => searchSpuId; set { Set(ref searchSpuId, value); } }

        /// <summary>
        /// 查询拳探订单号
        /// </summary>
        private string searchOrderSn;
        public string SearchOrderSn { get => searchOrderSn; set { Set(ref searchOrderSn, value); } }

        /// <summary>
        /// 查询名称
        /// </summary>
        private string selectTitle = "SKU名称";
        public string SelectTitle
        {
            get => selectTitle;


            set
            {
                Set(ref selectTitle, value);

                OnSelectTitleChanged(SelectTitle);
            }
        }

        private void OnSelectTitleChanged(string SelectTitle)
        {
            if (SelectTitle == "SKU名称")
            {
                SearchSpuTitle = null;
            }
            if (SelectTitle == "标题")
            {
                SearchSkuTitle = null;
            }

        }

        /// <summary>
        /// 查询店铺
        /// </summary>
        private string selectShop = "店铺";
        public string SelectShop
        {
            get => selectShop;


            set
            {
                Set(ref selectShop, value);

                OnSelectShopChanged(selectShop);
            }
        }
        private string searchShopName;
        public string SearchShopName
        {
            get => searchShopName; set
            {
                Set(ref searchShopName, value);
            }
        }

        private void OnSelectShopChanged(string selectShop)
        {
            if (selectShop == "店铺")
            {
                SearchDepartment = null;
            }
            if (selectShop == "部门")
            {
                SearchShopName = null;
            }

        }
        private string searchExpressName;
        public string SearchExpressName
        {
            get => searchExpressName; set
            {
                Set(ref searchExpressName, value);
            }
        }

        /// <summary>
        /// 查询物流
        /// </summary>
        private string selectExpress = "物流单号";
        public string SelectExpress
        {
            get => selectExpress;


            set
            {
                Set(ref selectExpress, value);

                OnSelectExpressChanged(SelectExpress);
            }
        }
        private string searchWayBillNo;
        public string SearchWayBillNo
        {
            get => searchWayBillNo; set
            {
                Set(ref searchWayBillNo, value);
            }
        }
        private void OnSelectExpressChanged(string SelectExpress)
        {
            if (SelectExpress == "物流单号")
            {
                SearchExpressName = null;
            }
            if (SelectExpress == "物流公司名称")
            {
                SearchWayBillNo = null;
            }

        }


        /// <summary>
        /// 查询物流
        /// </summary>
        private string selectTaskId = "任务ID";
        public string SelectTaskId
        {
            get => selectTaskId;


            set
            {
                Set(ref selectTaskId, value);

                OnSelectTaskIdChanged(SelectTaskId);
            }
        }
        /// <summary>
        /// 查询任务id
        /// </summary>
        private string searchTaskId;
        public string SearchTaskId
        {
            get => searchTaskId; set
            {
                Set(ref searchTaskId, value);
            }
        }
        private void OnSelectTaskIdChanged(string SelectTaskId)
        {
            if (SelectTaskId == "任务ID")
            {
                SearchOrderSn = null;
            }
            if (SelectTaskId == "拳探订单号")
            {
                SearchTaskId = null;
            }

        }
        /// <summary>
        /// 查询sku
        /// </summary>
        private string selectSku = "SKU";
        public string SelectSku
        {
            get => selectSku;
            set
            {
                Set(ref selectSku, value);
                OnSelectSkuChanged(SelectSku);
            }
        }
        private void OnSelectSkuChanged(string SelectSku)
        {
            if (SelectSku == "SKU")
            {
                SearchSpuId = null;
            }
            if (SelectSku == "SPU")
            {
                SearchSkuId = null;
            }

        }



        /// <summary>
        /// 查询拳探订单号
        /// </summary>
        private ObservableCollection<PackerTaskModel> packerTaskModelList;
        public ObservableCollection<PackerTaskModel> PackerTaskModelList { get => packerTaskModelList; set { Set(ref packerTaskModelList, value); } }


        private PackagingTaskExceptionState? packagingTaskExceptionState = Models.PackagingTaskExceptionState.待包装;
        /// <summary>
        /// 任务状态
        /// </summary>
        public PackagingTaskExceptionState? PackagingTaskExceptionState
        {
            get => packagingTaskExceptionState; set
            {
                Set(ref packagingTaskExceptionState, value);
            }
        }



        private string packagingTaskExceptionCount;
        /// <summary>
        /// 包装异常总数
        /// </summary>
        public string PackagingTaskExceptionCount { get => packagingTaskExceptionCount; set { Set(ref packagingTaskExceptionCount, value); } }

        private string packagingTaskCount;
        /// <summary>
        /// 待包装总数
        /// </summary>
        public string PackagingTaskCount { get => packagingTaskCount; set { Set(ref packagingTaskCount, value); } }








        #endregion


        PackUserService packUserService;

        PackTaskService packTaskService;
        /// <summary>
        /// 提交超时原因
        /// </summary>
        public ICommand SubmitOverTimeMarkMsgCommand { get; set; }
        /// <summary>
        /// 打开图片链接
        /// </summary>
        public ICommand OpenSkuDetailCommand { get; set; }
        public ICommand SearchTaskCommand { get; set; }
        /// <summary>
        /// 页面改变事件
        /// </summary>
        public ICommand TaskPageIndexChangedCommand { get; set; }

        public ICommand LookCerCommand { get; set; }
        public ICommand LookBarCommand { get; set; }

        public ICommand SetTaskStateCommand { get; set; }

        public ICommand CompletedPackTaskCommand { get; set; }
        public ICommand PackTaskMarkMessageCommand { get; set; }
        public ICommand AppendMarkMessageCommand { get; set; }

        public ICommand ShowMoreMessageCommand { get; set; }

        public ICommand PrintBarcodeCommand { get; set; }
        public ICommand PrintCerCommand { get; set; }


        public ICommand SetPackagingTaskExceptionStateCommand { get; set; }

        public ICommand TaskSplitCommand { get; set; }

        public ICommand PackagingTaskExceptionCommand { get; set; }


        /// <summary>
        /// 构造函数
        /// </summary>
        public PackerTaskViewModel(PackUserService packUserService, PackTaskService packTaskService, MarkMessageService markMessageService, GlobalContext globalContext, QualityTaskService qualityTaskService)
        {

            this.packUserService = packUserService;


            SetTaskStateCommand = new RelayCommand(SetTaskState);

            PackerTaskModelList = new ObservableCollection<PackerTaskModel>();

            OpenSkuDetailCommand = new RelayCommand<object>(OpenSkuDetail);
            SearchTaskCommand = new RelayCommand(() =>
            {

                PageIndex = 1;
                SearchTaskList();
            });
            TaskPageIndexChangedCommand = new RelayCommand<PageArgs>(p =>
            {
                LoadIndex(p.PageIndex);
            });
            SubmitOverTimeMarkMsgCommand = new RelayCommand<object>(SubmitOverTimeMarkMsg);
            this.packTaskService = packTaskService;



            LookBarCommand = new RelayCommand<BarCodeModel>(LookBar);
            LookCerCommand = new RelayCommand<CertificateModel[]>(LookCer);

            CompletedPackTaskCommand = new RelayCommand<long>(CompletedPackTask);
            PackTaskState = Models.PackTaskState.待包装;
            SetTaskState();
            PackTaskMarkMessageCommand = new RelayCommand<long>(PackTaskMarkMessage);
            AppendMarkMessageCommand = new RelayCommand<long>(AppendMarkMessage);
            this.markMessageService = markMessageService;
            this.globalContext = globalContext;

            ShowMoreMessageCommand = new RelayCommand<long>(ShowMoreMessage);

            PrintBarcodeCommand = new RelayCommand<BarCodeModel>(PrintBarcode);
            PrintCerCommand = new RelayCommand<CertificateModel[]>(PrintCer);

            SetPackagingTaskExceptionStateCommand = new RelayCommand(() =>
            {
                this.SearchTaskList();
            });


            TaskSplitCommand = new RelayCommand<PackerTaskModel>(TaskSplit);

            PackagingTaskExceptionCommand = new RelayCommand<long>(PackagingTaskException);
            this.qualityTaskService = qualityTaskService;


        
        }
        QualityTaskService qualityTaskService;
        private void PackagingTaskException(long taskId)
        {


            //AddExceptionWindow addExceptionWindow = new AddExceptionWindow(qualityTaskService, taskId, Models.TaskState.待包装, ReflashTask);
            //addExceptionWindow.ShowDialog();
        }

        private void TaskSplit(PackerTaskModel model)
        {

            //SplitTaskWindow addExceptionWindow = new SplitTaskWindow(packTaskService, model.TaskId, model.TaskState.Value, ReflashTask);
            //addExceptionWindow.ShowDialog();
        }

        private void PrintCer(CertificateModel[] certificateModel)
        {
            if (certificateModel == null)
            {
                new TipsWindow("该任务无设置合格证信息,无法打印!").Show();
                return;
            }
            PrintWindow printWindow = new PrintWindow();

            printWindow.CertificateModel = certificateModel;
            printWindow.LoadData();
            //printWindow.Datas = LoadCerLabelModels();
            printWindow.ShowDialog();
        }

        /// <summary>
        /// 打印条形码
        /// </summary>
        private void PrintBarcode(BarCodeModel BarCodeModel)
        {
            if (BarCodeModel == null)
            {
                new TipsWindow("该任务无设置条形码信息,无法打印!").Show();
                return;
            }

            PrintWindow printWindow = new PrintWindow();
            printWindow.BarCodeModel = new BarCodeModel
            {
                Brand = BarCodeModel.Brand,
                BrandName = BarCodeModel.BrandName,
                LabelModel = BarCodeModel.LabelModel,
                ProductNo = BarCodeModel.ProductNo,
                SkuId = BarCodeModel.SkuId,
                SkuName = BarCodeModel.SkuName,
                ShopName = BarCodeModel.ShopName
            };
            printWindow.LoadData();
            //printWindow.Datas = LoadBarLabelModels();
            printWindow.ShowDialog();
        }


        private void ShowMoreMessage(long taskId)
        {
            var model = PackerTaskModelList?.SingleOrDefault(p => p.TaskId == taskId);
            if (model != null)
            {
                model.ShowMoreMsg = !model.ShowMoreMsg;



            }
        }

        MarkMessageService markMessageService;
        GlobalContext globalContext;
        private void AppendMarkMessage(long taskId)
        {
            var model = PackerTaskModelList?.SingleOrDefault(p => p.TaskId == taskId);
            if (model != null)
            {

                var res = markMessageService.AppendMarkMessage(taskId, model.TaskMarkMsg, globalContext.User.Name);
                if (res == null)
                {

                    return;
                }
                if (!res.Success)
                {
                    MessageBox.Show(res.Msg);
                    return;
                }

                model.TaskMarkMsg = string.Empty;

                model.ShowSendMsg = false;

                ReflashTask();

            }


        }


        private void PackTaskMarkMessage(long taskId)
        {
            var model = PackerTaskModelList?.SingleOrDefault(p => p.TaskId == taskId);
            if (model != null)
            {
                model.ShowSendMsg = !model.ShowSendMsg;
            }
        }

        private void CompletedPackTask(long taskId)
        {
            AddOneItemWeightWindow addOneItemWeightWindow = new AddOneItemWeightWindow(ReflashTask, packUserService, taskId);
            addOneItemWeightWindow.ShowDialog();
        }



        #region 方法

        public void SetTaskState()
        {
            PageIndex = 1;
            SearchTaskList();

        }


        /// <summary>
        /// 查看合格证
        /// </summary>
        private void LookCer(CertificateModel[] CertificateModel)
        {
            if (CertificateModel == null)
            {
                new TipsWindow("该任务无设置合格证信息,无法查看!").ShowDialog();
                return;
            }
            LookCerWindow lookCerWindow = new LookCerWindow(CertificateModel);
            lookCerWindow.ShowDialog();
        }

        /// <summary>
        /// 查看条形码
        /// </summary>
        private void LookBar(BarCodeModel BarCodeModel)
        {
            if (BarCodeModel == null)
            {
                new TipsWindow("该任务无设置条形码信息,无法查看!").ShowDialog();
                return;
            }
            LookBarCodeWindow look = new LookBarCodeWindow();
            look.SetData(BarCodeModel.Copy());
            look.Show();
        }

        private void LoadIndex(int pageIndex)
        {
            PageIndex = pageIndex;//
            SearchTaskList();
        }



        private Thread packOverTimeThread = null;
        bool IsStartThread = false;
        private void SearchTaskList()
        {


            if (IsLoading)
            {
                return;
            }
            IsLoading = true;
            IsStartThread = false;
            Task.Factory.StartNew(() =>
            {

                var res = packUserService.SearchPackerTask(PackTaskState: PackTaskState, WayBillNo: SearchWayBillNo, SourceExpressName: SearchExpressName,
                    departmentName: SearchDepartment, SearchSkuId, SearchTaskId, SearchSpuId, SearchOrderSn, SearchShopName, PageIndex, PageSize, SearchSkuTitle, SearchSpuTitle,
                    PackagingTaskExceptionState
                    );
                if (res.Success)
                {
                    WaitPackCount = res.Data.WaitPackCount;
                    OrderCount = res.Data.TotalCount;
                    PackagingTaskExceptionCount = res.Data.PackagingTaskExceptionCount;
                    packagingTaskCount = res.Data.PackagingTaskCount;
                    PackerTaskModelList = new ObservableCollection<PackerTaskModel>();
                    res.Data.Items.ForEach(item =>
                    {

                        var data = JsonConvert.DeserializeObject<PackerTaskModel>(JsonConvert.SerializeObject(item));


                        if (PackTaskState == Models.PackTaskState.已完成)
                        {

                            if (item.PackCompletionOverTime < item.PackCompletionTime)//超时
                            {
                                data.IsPackOverTime = true;
                                data.PackRemainTime = OverTimeHelper.GetTimeString(item.PackCompletionTime.Value.Subtract(item.PackCompletionOverTime.Value));
                            }
                            else
                            {
                                data.IsPackOverTime = false;
                                data.PackRemainTime = OverTimeHelper.GetTimeString(item.PackCompletionTime.Value.Subtract(item.SetPackUserTaskTime.Value));
                            }
                        }

                        App.Current.Dispatcher.Invoke(() =>
                        {

                            PackerTaskModelList.Add(data);
                        });



                    });


                    if (PackTaskState == Models.PackTaskState.待包装)
                    {






                        if (PackagingTaskExceptionState == Models.PackagingTaskExceptionState.待包装)
                        {
                            var packCompletedTasks = PackerTaskModelList.Where(p => p.TaskState == Models.TaskState.待包装 && p.PackCompletionOverTime != null && p.TaskAbortTime == null).ToList();
                            if (packCompletedTasks.Count() > 0)
                            {

                                packOverTimeThread = new Thread(() =>
                                {
                                    IsStartThread = true;
                                    while (IsStartThread)
                                    {
                                        App.Current.Dispatcher.BeginInvoke(new Action(() =>
                                        {
                                            foreach (var item in packCompletedTasks)
                                            {
                                                var datetime = item.PackCompletionOverTime.Value.Subtract(DateTime.Now);
                                                if (datetime.TotalMilliseconds > 0)
                                                {
                                                    item.IsPackOverTime = false;
                                                    item.PackRemainTime = OverTimeHelper.GetTimeString(datetime);
                                                }
                                                else
                                                {
                                                    item.IsPackOverTime = true;
                                                    item.PackRemainTime = OverTimeHelper.GetTimeString(datetime);
                                                }

                                            }
                                        }));
                                        Thread.Sleep(1000);
                                    }

                                });
                                //任务倒计时数据
                                packOverTimeThread.IsBackground = true;
                                packOverTimeThread.Start();


                            }
                        }





                        if (PackagingTaskExceptionState == Models.PackagingTaskExceptionState.挂起任务)
                        {
                            var packtasks = PackerTaskModelList.Where(p => p.TaskState == Models.TaskState.待包装 && p.TaskAbortTime != null).ToList();
                            App.Current.Dispatcher.BeginInvoke(new Action(() =>
                            {
                                foreach (var item in packtasks)
                                {
                                    TimeSpan datetime;
                                    datetime = item.PackCompletionOverTime.Value.Subtract(item.TaskAbortTime.Value);
                                    item.PackRemainTime = OverTimeHelper.GetTimeString(datetime);
                                    if (datetime.TotalMilliseconds > 0)
                                    {
                                        item.IsPackOverTime = false;

                                    }
                                    else
                                    {
                                        item.IsPackOverTime = true;
                                    }

                                }
                            }));
                        }
                    }
                }
                else
                {
                    MessageBox.Show(res?.Msg ?? "未知错误");
                }
                IsLoading = false;
            });
        }

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


        private void SubmitOverTimeMarkMsg(object param)
        {

            var paramList = (object[])param;
            var id = (long)paramList[0];
            var markMsg = paramList[1]?.ToString();

            var overTimeTaskType = Models.OverTimeTaskType.待打包;


            SubmitOverTimeMarkMsgWindow submitOverTimeMarkMsgWindow = new SubmitOverTimeMarkMsgWindow(overTimeTaskType, id, markMsg, packTaskService, ReflashTask);
            submitOverTimeMarkMsgWindow.ShowDialog();
        }
        public void ReflashTask()//刷新界面
        {
            SearchTaskList();
        }
        #endregion


    }
}