using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Infrastructure.Attribute;
using DOAN.Service.JobKanban.IService;
using DOAN.Model.MES.product;
using DOAN.Model.MES.base_;
using DOAN.Model.MES.product.Dto;
using DOAN.Model.MES.mm;
using DOAN.Model.JobKanban;

namespace DOAN.Service.JobKanban
{
    [AppService(ServiceType = typeof(IWorkorderProgressService), ServiceLifetime = LifeTime.Transient)]
    public class WorkorderProgressService : BaseService<ProWorkorder>, IWorkorderProgressService
    {

        public List<BaseWorkRoute> GetRoutes()
        {
            return Context.Queryable<BaseWorkRoute>().Where(it => it.Status == 1).ToList();

        }
        public List<BaseGroup> GetGroups()
        {
            return Context.Queryable<BaseGroup>().Where(it => it.Status == 1).ToList();
        }


        public List<ProWorkorder> GetWorkOrderList(string group_code, string line_code, DateTime handleDate)
        {
            handleDate = handleDate.ToLocalTime().Date;

            return Context.Queryable<ProWorkorder>().Where(it => it.GroupCode == group_code)
                  .Where(it => it.LineCode == line_code)
                  .Where(it => it.WorkorderDate == handleDate)
                  .ToList();
        }

        /// <summary>
        /// 获取工单列表 未完成
        /// </summary>
        /// <param name="today"></param>
        /// <param name="LineCode"></param>
        /// <returns></returns>
        public List<ProWorkorderDto4> GetWorkOrderListNoFinish(DateTime today, string line_code, string group_code)
        {
            today = today.ToLocalTime().Date;
            var query1 = Context.Queryable<ProWorkorder>()
                .Where(it => it.WorkorderDate == today)
                .Where(it => it.LineCode == line_code)
                .Where(it => it.GroupCode == group_code)
                .Where(it => it.Status == 1 || it.Status == 2)
                ;


            List<ProWorkorderDto4> ProWorkorderDto4List = Context.Queryable(query1)
                 .LeftJoin<ProReportwork>((q, r) => q.Workorder == r.FkWorkorder)
                 .Select((q, r) => new ProWorkorderDto4()
                 {
                     FinishNum = r.FinishedNum

                 }, true)
                 .MergeTable()
                 .OrderBy(it => it.Sort)
                 .ToList();
            if (ProWorkorderDto4List.Count > 0)
            {
                foreach (var item in ProWorkorderDto4List)
                {
                    item.progress = SearchMaterialPreparationProgress(item.Workorder);
                }


            }


            return ProWorkorderDto4List;
        }
        /// <summary>
        ///  根据工单号 查询每个工单号进度
        /// </summary>
        /// <param name="Workorder"></param>
        /// <returns></returns>
        private MaterialPreparationProgress SearchMaterialPreparationProgress(string Workorder)
        {



            MaterialPreparationProgress progress = new MaterialPreparationProgress();
            //TODO 查询工单总任务数
            progress.WorkOrder = Workorder;
            progress.Preparation_all_num = Context.Queryable<MmPreparationTask>().Where(it => it.FkWorkorder == Workorder)
                .Count();

            progress.Preparationed_num = Context.Queryable<MmPreparationTask>().Where(it => it.FkWorkorder == Workorder)
                 .Where(it => it.PreparationStatus == 2)
                .Count();
            if (progress.Preparationed_num == progress.Preparation_all_num)
            {
                progress.PreparationStatus = 2;

            }
            else if (progress.Preparationed_num < progress.Preparation_all_num)
            {
                progress.PreparationStatus = 1;
            }

            if (progress.Preparation_all_num == 0)
            {
                progress.PreparationStatus = 0;
            }








            return progress;


        }
        public ProWorkorderDto4 GetWorkOrderDetail(string workorder)
        {
            var query = Context.Queryable<ProWorkorder>()
                .Where(it => it.Workorder == workorder);



            return Context.Queryable(query)
                .LeftJoin<ProReportwork>((q, r) => q.Workorder == r.FkWorkorder)
                .Select((q, r) => new ProWorkorderDto4()
                {
                    FinishNum = r.FinishedNum

                }, true).First();

        }

        public KanbanInfo GetKanbanNum(DateTime today, string line_code, string group_code)
        {
            KanbanInfo kanbanInfo = new KanbanInfo();
            today = today.ToLocalTime().Date;
            kanbanInfo.TotalTaskNum = Context.Queryable<ProWorkorder>()
               .Where(it => it.WorkorderDate == today)
               .Where(it => it.LineCode == line_code)
               .Where(it => it.GroupCode == group_code)
               .Count();

            kanbanInfo.RemainTasKNum = Context.Queryable<ProWorkorder>()
               .Where(it => it.WorkorderDate == today)
               .Where(it => it.LineCode == line_code)
                .Where(it => it.GroupCode == group_code)
               .Where(it => it.Status == 1 || it.Status == 2)
               .Count();

            return kanbanInfo;
        }

        public int StartWorkOrder(string workorder)
        {
            int result = 0;
            // 获取同一天 同一组 同一线 的所有工单 把状态2 设为init 1
            ProWorkorder handleWorkorder = Context.Queryable<ProWorkorder>().Where(it => it.Workorder == workorder).First();
            UseTran2(() =>
            {
                Context.Updateable<ProWorkorder>().SetColumns(it => it.Status == 1)
                               .Where(it => it.Status == 2)
                               .Where(it => it.WorkorderDate == handleWorkorder.WorkorderDate)
                               .Where(it => it.GroupCode == handleWorkorder.GroupCode)
                               .Where(it => it.LineCode == handleWorkorder.LineCode)
                               .ExecuteCommand();


                result = Context.Updateable<ProWorkorder>().SetColumns(it => it.Status == 2)
                .SetColumns(it => it.StartTime == DateTime.Now)
                                   .Where(it => it.Workorder == workorder).ExecuteCommand();
            });
            return result;

        }

        public int FinishWorkOrder(string workorder)
        {
            return Context.Updateable<ProWorkorder>()
                .SetColumns(it => it.Status == 3)
                .SetColumns(it=>it.EndTime == DateTime.Now) 
               .Where(it => it.Workorder == workorder).ExecuteCommand();
        }

        public ProWorkorder GetProductingWorkorder(string line_code, DateTime handleDate)
        {
            //TODO 这个日期有问题？？？？？？
            if (handleDate.Kind == DateTimeKind.Utc)
            {

                handleDate = handleDate.ToLocalTime().Date;
            }
            else
            {
                handleDate = handleDate.Date;
            }


            return Context.Queryable<ProWorkorder>()
                  .Where(it => it.LineCode == line_code)
                  .Where(it => it.WorkorderDate == handleDate)
                  .Where(it => it.Status == 2)
                  //.Select(it=>it.Workorder)
                  .First();

        }

        public int AddLabelLog(string labelContext, string workOrder)
        {
            ProLabelTraceLog log = new ProLabelTraceLog();
            log.Id = XueHua;
            log.LabelContext = labelContext;
            log.Workorder = workOrder;
            log.Status = 1;
            log.CreatedTime = DateTime.Now;
            log.CreatedBy = "MES";

            return Context.Insertable(log).ExecuteCommand();
        }


        public int LabelWorkOrderMatch(string LabelContext, string workOrder)
        {

            return Context.Updateable<ProLabelTraceLog>()
                .Where(it => it.Workorder == workOrder)
                .Where(it => it.LabelContext == LabelContext)
                .SetColumns(it => it.Status == 1)
                .ExecuteCommand();
        }



        public int FinishAndReportWorkorder(string workorder, int finish_num)
        {
            int result = 0;
            // 1 查询工单
            ProWorkorder workorder1 = Context.Queryable<ProWorkorder>().Where(it => it.Workorder == workorder).First();



            ProReportwork reportWork = new ProReportwork();
            reportWork.Id = XueHua;
            reportWork.FkWorkorder = workorder;
            reportWork.DispatchNum = workorder1.DeliveryNum;
            reportWork.FinishedNum = finish_num;
            reportWork.GroupCode = workorder1.GroupCode;
            reportWork.LineCode = workorder1.LineCode;

            reportWork.CreatedTime = DateTime.Now;
            reportWork.CreatedBy = "kanban";
            UseTran2(() =>
            {
                Context.Storageable(reportWork)
                 .WhereColumns(it => it.FkWorkorder)
                 .ExecuteCommand();
                result = Context.Updateable<ProWorkorder>()
                   .Where(it => it.Workorder == workorder)
                   .SetColumns(it => it.Status == 3)
                   .ExecuteCommand();

            });

            return result;
        }
    }

}