using AutoMapper;
using AutoMapper.Internal;
using BBWY.Client.APIServices;
using BBWY.Client.Models;
using BBWY.Client.Models.APIModel.Request;
using BBWY.Client.Models.APIModel.Response.PackTask;
using BBWY.Client.Models.PackTask;
using BBWY.Client.Views.PackTask;
using BBWY.Common.Models;
using GalaSoft.MvvmLight.Command;
using Microsoft.Extensions.Logging;
using Org.BouncyCastle.Asn1.Crmf;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq;
using System.Reflection.Metadata.Ecma335;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Controls;
using System.Windows.Controls.Primitives;
using System.Windows.Input;

namespace BBWY.Client.ViewModels.PackTask
{
    public class PackServiceViewModel : BaseVM, IDenpendency
    {




        public ICommand AddPackServiceCommand { get; set; }

        public ICommand AddIncreateServiceCommand { get; set; }

        public ICommand AddConsumableCommand { get; set; }

        public ICommand UpLoadPackCommand { get; set; }

        public ICommand SetAllCountCommand { get; set; }

        readonly PackTaskService packTaskService;
        readonly ConsumableService consumableService;
        readonly PackDetailService packDetailService;

        private ObservableCollection<PackItemModel> increateList = new ObservableCollection<PackItemModel>();
        public ObservableCollection<PackItemModel> IncreateList { get => increateList; set { Set(ref increateList, value); } } //

        private ObservableCollection<PackItemModel>
            packList = new ObservableCollection<PackItemModel>();
        public ObservableCollection<PackItemModel> PackList { get => packList; set { Set(ref packList, value); } } //

        private ObservableCollection<PackItemModel>
            consumableServiceList = new ObservableCollection<PackItemModel>();
        public ObservableCollection<PackItemModel> ConsumableServiceList { get => consumableServiceList; set { Set(ref consumableServiceList, value); } } //

        private string discount = "1";
        /// <summary>
        /// 折扣
        /// </summary>
        public string Discount { get => discount; set { Set(ref discount, value); } } //


        public ObservableCollection<PackServiceDTO> IncreateServiceList { get; set; } = new ObservableCollection<PackServiceDTO>();
        public ObservableCollection<PackUser> MemberList { get; set; } = new ObservableCollection<PackUser>();
        public ObservableCollection<ConsumableModel> ConsumableList { get; set; } = new ObservableCollection<ConsumableModel>();
        public ObservableCollection<PackServiceDTO> PackServiceList { get; set; } = new ObservableCollection<PackServiceDTO>();

        private readonly PackServiceService packServiceService;

        /// <summary>
        /// 加载原数据
        /// </summary>
        public List<PackItemModel> LoadList = new List<PackItemModel>();

        public PackServiceViewModel(PackTaskService packTaskService, ConsumableService consumableService, PackServiceService packServiceService, PackDetailService packDetailService)//, long taskId
        {
            //TaskId = taskId;
            this.consumableService = consumableService;
            this.packTaskService = packTaskService;
            this.packServiceService = packServiceService;
            this.packDetailService = packDetailService;




            var packServiceRes = this.packServiceService.SearchAll();


            if (packServiceRes.Success)
            {
                if (packServiceRes.Data != null && packServiceRes.Data.Count() > 0)
                {

                    foreach (var packService in packServiceRes.Data)
                    {
                        if (packService.ServiceType == ServiceType.增值服务)
                            App.Current.Dispatcher.Invoke(() =>
                            {
                                IncreateServiceList.Add(packService);//加载增值服务列表
                            });
                        if (packService.ServiceType == ServiceType.打包服务)
                            App.Current.Dispatcher.Invoke(() =>
                            {
                                PackServiceList.Add(packService);//加载工序服务列表
                            });
                    }
                }
            }



            var res = this.packTaskService.GetPackMembers();//成员表
            if (res.Success)
            {
                foreach (var item in res.Data)
                {
                    App.Current.Dispatcher.Invoke(() =>
                    {
                        MemberList.Add(item);
                    });

                }

            }



            var conRes = this.consumableService.SearchAll();
            if (conRes.Success)
            {
                foreach (var item in conRes.Data)
                {
                    App.Current.Dispatcher.Invoke(() =>
                    {

                        ConsumableList.Add(new ConsumableModel(consumableService)
                        {
                            Width = item.Width,
                            Weigth = item.Weigth,
                            Remark = item.Remark,
                            Price = item.Price,
                            Name = item.Name,
                            Length = item.Length,
                            Heigth = item.Heigth,
                            Id = item.Id
                        });
                    });
                }

            }



            AddIncreateServiceCommand = new RelayCommand(AddIncreateService);
            AddPackServiceCommand = new RelayCommand(AddPackService);
            AddConsumableCommand = new RelayCommand(AddConsumable);
            UpLoadPackCommand = new RelayCommand<object>(UpLoadPack);
            SetAllCountCommand = new RelayCommand<object>(SetAllCount);





            //加载数据
            //LoadPackDatas();

        }

        /// <summary>
        /// 加载任务数据
        /// </summary>
        public void LoadPackDatas()
        {
            LoadList = new List<PackItemModel>();
            Task task = Task.Factory.StartNew(() =>
            {
                var res = this.packDetailService.GetTaskService(TaskId);
                if (res.Success)
                {
                    if (res.Data.IncreateList != null)
                    {
                        IncreateList = new ObservableCollection<PackItemModel>();

                        foreach (var item in res.Data.IncreateList)
                        {
                            App.Current.Dispatcher.Invoke(() =>
                            {
                                IncreateList.Add(new PackItemModel()
                                {
                                    MemberList = MemberList,
                                    IncreateServiceList = IncreateServiceList,
                                    ItemCount = item.ItemCount,
                                    ItemName = item.ItemName,
                                    SelectId = item.SelectId,
                                    SelectUserId = item.SelectUserId,
                                    MemberName = item.MemberName

                                });
                            });
                        }

                    }
                    if (res.Data.PackList != null)
                    {
                        PackList = new ObservableCollection<PackItemModel>();
                        foreach (var item in res.Data.PackList)
                        {
                            App.Current.Dispatcher.Invoke(() =>
                            {
                                PackList.Add(new PackItemModel()
                                {
                                    PackServiceList = PackServiceList,
                                    MemberList = MemberList,
                                    ItemCount = item.ItemCount,
                                    ItemName = item.ItemName,
                                    SelectId = item.SelectId,
                                    SelectUserId = item.SelectUserId,
                                    MemberName = item.MemberName

                                });
                            });
                        }
                    }
                    if (res.Data.ConsumableServiceList != null)
                    {
                        ConsumableServiceList = new ObservableCollection<PackItemModel>();
                        foreach (var item in res.Data.ConsumableServiceList)
                        {
                            App.Current.Dispatcher.Invoke(() =>
                            {
                                ConsumableServiceList.Add(new PackItemModel()
                                {
                                    MemberList = MemberList,
                                    ConsumableList = ConsumableList,
                                    ItemCount = item.ItemCount,
                                    ItemName = item.ItemName,
                                    SelectId = item.SelectId,


                                });
                            });
                        }
                    }
                    LoadList.AddRange(IncreateList);
                    LoadList.AddRange(PackList);
                    Discount =res.Data.Discount.ToString();
                }

            });
        }

        /// <summary>
        /// 批量设置耗材数量
        /// </summary>
        /// <param name="obj"></param>
        private void SetAllCount(object obj)
        {

            SetCountWindow set = new SetCountWindow();
            set.SetCount = new Action<int>((s) =>
            {
                var lbox = obj as ListBox;
                var serviceList = lbox.ItemsSource as ObservableCollection<PackItemModel>;
                foreach (var item in serviceList)
                {
                    if (item.ItemName == null)
                    {
                        item.ItemName = ConsumableList.SingleOrDefault(c => c.Id == item.SelectId).Name;
                    }

                    item.ItemCount = s;
                }
                lbox.ItemsSource = serviceList;
            });
            set.Show();
        }

        private long taskId;
        public long TaskId { get => taskId; set { Set(ref taskId, value); } } //


        private int taskCount;
        public int TaskCount { get => taskCount; set { Set(ref taskCount, value); } } //

        /// <summary>
        /// 上传数据   (判断是否超量)  统一上传
        /// </summary>
        private void UpLoadPack(object obj)
        {
            decimal upDisCount = 1;
            if (string.IsNullOrEmpty(Discount)) upDisCount = 1;

            decimal.TryParse(Discount, out upDisCount);
            if (upDisCount == 0)
            {
                new TipsWindow("折扣输入有误");
                return;
            }
            UploadServiceRequest uploadService = new UploadServiceRequest();
            uploadService.Discount = upDisCount;

            List<PackItemModel> packServiceList = new List<PackItemModel>();



            uploadService.TaskId = TaskId;
            List<PackServiceDTO> uploadServices = new List<PackServiceDTO>();

            //  List<ConsumableTaskModel> consumableTasks = new List<ConsumableTaskModel>();
            ///上传 删除的数据   //上传保存数据  //上传总数据
            List<PersonTaskModel> addDatas = new List<PersonTaskModel>();
            List<PersonTaskModel> delDatas = new List<PersonTaskModel>();

            List<PersonTaskModel> PersonTaskModels = new List<PersonTaskModel>();


            List<PackServiceMemberModel> allPackServiceTasks = new List<PackServiceMemberModel>();
            List<ConsumableTaskModel> allConsumableTasks = new List<ConsumableTaskModel>();
            FeesItemResponse feesItem = new FeesItemResponse(); ;
            List<PackServiceMemberModel> PackServiceMembers = new List<PackServiceMemberModel>();
            //获取打包人员
            List<string> packUsers = new List<string>();

            decimal singleFees = 0;
            decimal AllFees = 0;
            decimal price = 0;

            decimal IncreateFees = 0,PackFees=0,ConsumableFees=0,DiscountPrice=0;
            foreach (var item in IncreateList)//增值服务上传
            {
                if (item.SelectId <= 0 || string.IsNullOrEmpty(item.SelectUserId) || item.ItemCount <= 0)
                {
                    new TipsWindow($"数据输入有误").Show();
                    return;
                }
                var member = MemberList.SingleOrDefault(m => m.Id == item.SelectUserId);
                if (member != null && !packUsers.Contains(member.UserName))
                {
                    packUsers.Add(member.UserName);
                }

                if (item.ItemCount > TaskCount)
                {
                    new TipsWindow($"{item.ItemName}:{item.ItemCount}超出任务量{TaskCount}").Show();
                    return;
                }
                price = IncreateServiceList.First(i => i.Id == item.SelectId).Price;
                singleFees += price;
                AllFees += item.ItemCount * price;
                IncreateFees += item.ItemCount * price;



                if (PackServiceMembers.Select(a => a.PackServiceId).Contains(item.SelectId))//相同服务 存在累加
                {
                    var inMembers = PackServiceMembers.SingleOrDefault(a => a.UserId == item.SelectUserId && a.PackServiceId == item.SelectId);
                    if (inMembers != null)
                        inMembers.PackServiceCount += item.ItemCount;



                    var data = PackServiceMembers.SingleOrDefault(a => a.PackServiceId == item.SelectId);
                    var feeItem = feesItem.ServiceList.SingleOrDefault(f => f.ItemName == item.ItemName);
                    if (data != null) data.PackServiceCount += item.ItemCount;
                    if (feeItem != null) feeItem.ItemCount += item.ItemCount;
                    if (data.PackServiceCount > TaskCount)//累积超出任务量
                    {
                        new TipsWindow($"{item.ItemName}:{data.PackServiceCount}超出任务量{TaskCount}").Show();
                        return;
                    }

                    continue;
                }

                PackServiceMembers.Add(new PackServiceMemberModel
                {
                    UserId = item.SelectUserId,
                    PackServiceCount = item.ItemCount,
                    PackServiceId = item.SelectId,
                    Price = price,
                    ServiceType = ServiceType.增值服务
                });


                feesItem.ServiceList.Add(new ServiceItemResponse
                {
                    ServiceType = ServiceType.增值服务,
                    ItemCount = item.ItemCount,
                    ItemName = item.ItemName,
                    ItemPrice = price
                });

            }

            foreach (var item in PackList)//打包服务
            {
                if (item.SelectId <= 0 || string.IsNullOrEmpty(item.SelectUserId) || item.ItemCount <= 0)
                {
                    new TipsWindow($"数据输入有误").Show();
                    return;
                }
                if (item.ItemCount > TaskCount)
                {
                    new TipsWindow($"{item.ItemName}:{item.ItemCount}超出任务量{TaskCount}").Show();
                    return;
                }
                var member = MemberList.SingleOrDefault(m => m.Id == item.SelectUserId);
                if (member != null && !packUsers.Contains(member.UserName))
                {
                    packUsers.Add(member.UserName);
                }


                price = PackServiceList.First(i => i.Id == item.SelectId).Price;
                singleFees += price;
                AllFees += item.ItemCount * price;
                PackFees += item.ItemCount * price;
                if (PackServiceMembers.Select(a => a.PackServiceId).Contains(item.SelectId))//存在累加
                {
                    var inMembers = PackServiceMembers.SingleOrDefault(a => a.UserId == item.SelectUserId && a.PackServiceId == item.SelectId);
                    if (inMembers != null)
                        inMembers.PackServiceCount += item.ItemCount;


                    var data = PackServiceMembers.SingleOrDefault(a => a.PackServiceId == item.SelectId);
                    var feeItem = feesItem.ServiceList.SingleOrDefault(f => f.ItemName == item.ItemName);
                    feeItem.ItemCount += item.ItemCount;
                    data.PackServiceCount += item.ItemCount;
                    if (data.PackServiceCount > TaskCount)//累积超出任务量
                    {
                        new TipsWindow($"{item.ItemName}:{data.PackServiceCount}超出任务量{TaskCount}").Show();
                        return;
                    }
                    continue;
                }
                PackServiceMembers.Add(new PackServiceMemberModel
                {
                    UserId = item.SelectUserId,
                    PackServiceCount = item.ItemCount,
                    PackServiceId = item.SelectId,
                    Price = price,
                    ServiceType = ServiceType.打包服务
                });
                feesItem.ServiceList.Add(new ServiceItemResponse
                {
                    ServiceType = ServiceType.打包服务,
                    ItemCount = item.ItemCount,
                    ItemName = item.ItemName,
                    ItemPrice = price
                });



            }

            foreach (var item in ConsumableServiceList)
            {
                if (item.SelectId <= 0 || item.ItemCount <= 0)
                {
                    new TipsWindow($"数据输入有误").Show();
                    return;
                }
                if (item.ItemCount > TaskCount)
                {
                    new TipsWindow($"{item.ItemName}:{item.ItemCount}超出任务量{TaskCount}").Show();
                    return;
                }
                price = ConsumableList.First(i => i.Id == item.SelectId).Price.Value;
                singleFees += price;
                AllFees += item.ItemCount * price;
                ConsumableFees += item.ItemCount * price;
                if (allConsumableTasks.Select(a => a.ConsumableId).Contains(item.SelectId))//存在累加
                {
                    var data = allConsumableTasks.SingleOrDefault(a => a.ConsumableId == item.SelectId);
                    var feeItem = feesItem.ServiceList.SingleOrDefault(f => f.ItemName == item.ItemName);
                    feeItem.ItemCount += item.ItemCount;
                    data.ConsumableCount += item.ItemCount;
                    if (data.ConsumableCount > TaskCount)//累积超出任务量
                    {
                        new TipsWindow($"{item.ItemName}:{data.ConsumableCount}超出任务量{TaskCount}").Show();
                        return;
                    }
                    continue;
                }
                feesItem.ServiceList.Add(new ServiceItemResponse
                {
                    ServiceType = ServiceType.耗材服务,
                    ItemCount = item.ItemCount,
                    ItemName = item.ItemName,
                    ItemPrice = price
                });
                allConsumableTasks.Add(new ConsumableTaskModel
                {
                    ConsumableCount = item.ItemCount,
                    ConsumableId = item.SelectId
                });
            }
            uploadService.ConsumableIds = string.Join(",", allConsumableTasks.Select(a => a.ConsumableId));
            uploadService.ConsumableNos = string.Join(",", allConsumableTasks.Select(a => a.ConsumableCount));
            uploadService.WorkProcessIds = string.Join(",", PackServiceMembers.Where(p => p.ServiceType == ServiceType.打包服务).Select(a => a.PackServiceId));
            uploadService.WorkProcessNos = string.Join(",", PackServiceMembers.Where(p => p.ServiceType == ServiceType.打包服务).Select(a => a.PackServiceCount));
            uploadService.IncreateServiceIds = string.Join(",", PackServiceMembers.Where(p => p.ServiceType == ServiceType.增值服务).Select(a => a.PackServiceId));
            uploadService.IncreateServiceNos = string.Join(",", PackServiceMembers.Where(p => p.ServiceType == ServiceType.增值服务).Select(a => a.PackServiceCount));

            uploadService.PackServiceIds = string.Join(",", PackServiceMembers.Select(a => a.PackServiceId));
            uploadService.PackServiceNos = string.Join(",", PackServiceMembers.Select(a => a.PackServiceCount));
            var orgIds = LoadList.Select(p => p.SelectId).ToList();
            var nowIds = PackServiceMembers.Select(p => p.PackServiceId).ToList();

            //var add =  nowIds.Except(orgIds);
            var del = orgIds.Except(nowIds).ToList();

            foreach (var PackServiceMember in PackServiceMembers)
            {
                addDatas.Add(new PersonTaskModel
                {
                    TaskId = taskId,
                    CreateTime = DateTime.Now,
                    IsDeleted = false,
                    ServiceCount = PackServiceMember.PackServiceCount,
                    PackUserId = PackServiceMember.UserId,
                    ServiceId = PackServiceMember.PackServiceId,
                    ServiceType = PackServiceMember.ServiceType
                });
            }
            uploadService.AddPackServices = addDatas;
            uploadService.DeletedPackServices = del;

            uploadService.AllFees = Convert.ToDecimal((AllFees).ToString("0.00")); ;
            uploadService.SingleFees = singleFees;
            uploadService.IncreaseFees = Convert.ToDecimal((IncreateFees).ToString("0.00"));
            uploadService.PackFees = Convert.ToDecimal((PackFees).ToString("0.00"));
            uploadService.ConsumableFees = Convert.ToDecimal((ConsumableFees).ToString("0.00"));
            uploadService. DiscountPrice = Convert.ToDecimal( (AllFees * upDisCount).ToString("0.00"));
            var res = packDetailService.UploadService(uploadService);
            if (res != null && res.Success)
            {
                // new TipsWindow("上传成功!").Show();
                var win = obj as System.Windows.Window;
                feesItem.AllFees = AllFees;
                feesItem.SingleFees = singleFees;
                feesItem.TaskId = TaskId;
                feesItem.DisCount = upDisCount;
                feesItem.DiscountAllFees = upDisCount * AllFees;
                feesItem.DiscountSingleFees = singleFees * upDisCount;
                if (SetAllFees != null)
                    SetAllFees(feesItem, packUsers);
                win.Close();
            }

        }
        /// <summary>
        /// 更新 打包员 和费用数据
        /// </summary>
        public Action<FeesItemResponse, List<string>> SetAllFees { get; set; }

        private void AddPackService()
        {
            PackList.Add(new PackItemModel()
            {
                ItemCount = TaskCount,
                MemberList = MemberList,
                PackServiceList = PackServiceList
            });
        }

        private void AddIncreateService()
        {
            IncreateList.Add(new PackItemModel()
            {
                ItemCount = TaskCount,
                IncreateServiceList = IncreateServiceList,
                MemberList = MemberList,
            });
        }

        private void AddConsumable()
        {
            ConsumableServiceList.Add(new PackItemModel()
            {
                ItemCount = TaskCount,
                ConsumableList = ConsumableList
            });
        }
    }
}