using Infrastructure.Attribute;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Reflection;
using ZR.Model.MES.pro;
using ZR.Model.MES.qc;
using ZR.Model.MES.qc.DTO;
using ZR.Model.MES.qu;
using ZR.Model.MES.wms;
using ZR.Service.mes.qc.IService;
using static System.Runtime.InteropServices.JavaScript.JSType;

namespace ZR.Service.mes.qc
{


    [AppService(ServiceType = typeof(ICommonFQCService), ServiceLifetime = LifeTime.Transient)]
    public class CommonFQCService : BaseService<FirstFQCService>, ICommonFQCService
    {
        public int CheckPackageWorkOrderStatus(string workOrderId)
        {
            try
            {
                // 检查对应工单是否存在
                ProWorkorder_v2 proWorkorder = Context.Queryable<ProWorkorder_v2>()
                .Where(it => it.ClientWorkorder == workOrderId)
                .First();
                if (proWorkorder == null)
                {
                    return -1;
                }
                return proWorkorder.Status;
            }
            catch (Exception ex)
            {
                return -1;
            }
        }
        /// <summary>
        /// 根据年周日生成当日全部工单列表
        /// </summary>
        /// <param name="year">年</param>
        /// <param name="week">周</param>
        /// <param name="date">日</param>
        /// <param name="type">0-不读取status 1-读取status 2- 查询status为1,2时</param>
        /// <param name="status">-1-全部 0-初态 1-上线 2-包装完成</param>
        /// <returns></returns>
        public List<ProWorkorder_v2> GenerateWorkOrderListUtil(int year, int week, int date,int type = 0,int status = -1)
        {
            try
            {
                var predicate = Expressionable.Create<ProWorkorder_v2>()
                                .And(it => it.Year == year)
                                .And(it => it.Week == week)
                                .And(it => it.Date == date)
                                .And(it => it.Remark3 == "是")
                                .AndIF(type  == 1, it => it.Status == status)
                                .AndIF(type == 2, it => it.Status == 1 || it.Status == 2)
                                .ToExpression();
                return Context.Queryable<ProWorkorder_v2>()
                        .Where(predicate)
                        .OrderBy(it => it.Sort)
                        .ToList();
            }
            catch (Exception ex)
            {
                return null;
            }

        }
        public int CheckPackageWorkOrderInListStatus(string workOrderId)
        {
            try
            {
                // 检查对应工单是否存在
                ProWorkorder_v2 proWorkOrder = Context.Queryable<ProWorkorder_v2>().Where(it => it.ClientWorkorder == workOrderId).First();
                if (proWorkOrder == null)
                {
                    return -1;
                }
                // 提取工单年周日,组成数组
                int year = proWorkOrder.Year;
                int week = proWorkOrder.Week;
                int date = proWorkOrder.Date;
                List < ProWorkorder_v2 > proWorkorders = GenerateWorkOrderListUtil(year, week, date,2);
                if (proWorkorders == null)
                {
                    return -1;
                }
                // 提取目标工单号所在工单列表的位置
                int index = -1;
                for (int i = 0; i < proWorkorders.Count; i++)
                {
                    if (workOrderId == proWorkorders[i].ClientWorkorder)
                    {
                        index = i; break;
                    }
                }
                if (index == 0)
                {
                    return 2;
                }
                
                for (int i = 0;i < index; i++)
                {
                    if(proWorkorders[i].Status == 1)
                    {
                        return 1;
                    }
                }

                if (index == proWorkorders.Count - 1)
                {
                    return 3;
                }
                return 0;
            }
            catch (Exception ex)
            {
                return -1;
            }
        }

        public int[] CheckWorkOrderInDayListNum(string workOrderId)
        {
            try
            {
                int[] result = new int[4];
                // 工单总数
                int workOrderTotal = 0;
                // 当前位置
                int index = 0;
                // 已完成
                int finishNum = 0;
                // 未完成
                int noFinishNum = 0;
                // 检查对应工单是否存在
                ProWorkorder_v2 proWorkOrder = Context.Queryable<ProWorkorder_v2>().Where(it => it.ClientWorkorder == workOrderId).First();
                if (proWorkOrder == null)
                {
                    return result;
                }
                // 提取工单年周日,组成数组
                int year = proWorkOrder.Year;
                int week = proWorkOrder.Week;
                int date = proWorkOrder.Date;
                List<ProWorkorder_v2> proWorkorders = GenerateWorkOrderListUtil(year, week, date,2);
                if (proWorkorders == null)
                {
                    return result;
                }
                workOrderTotal = proWorkorders.Count;
                // 提取目标工单号所在工单列表的位置
                for (int i = 0; i < proWorkorders.Count; i++)
                {
                    if (workOrderId == proWorkorders[i].ClientWorkorder)
                    {
                        index = i + 1; break;
                    }
                }
                List<ProWorkorder_v2> finishWorkorders = GenerateWorkOrderListUtil(year, week, date,1,2);
                if (finishWorkorders == null)
                {
                    return result;
                }
                finishNum = finishWorkorders.Count;
                noFinishNum = workOrderTotal - finishNum;

                // 最终赋值
                result.SetValue(index, 0);
                result.SetValue(workOrderTotal, 1);
                result.SetValue(finishNum, 2);
                result.SetValue(noFinishNum, 3);
                return result;
            }
            catch (Exception ex)
            {
                return null;
            }
        }
        /// <summary>
        /// 工单需要打印标签总数
        /// </summary>
        /// <param name="workOrderId">工单号</param>
        /// <param name="previousNumber">上件数</param>
        /// <returns></returns>
        public int GetWorkOrderNeedPackingTotal(string workOrderId)
        {
            try
            {
                ProWorkorder_v2 workOrder = Context.Queryable<ProWorkorder_v2>().Where(it => it.ClientWorkorder == workOrderId).First();
                var res = Context.Queryable<QcFirstinspectionRecord>()
                    .Where(it => it.FKWorkorderId.Equals(workOrderId))
                    .GroupBy(it => it.FKWorkorderId)
                    .Select(it => new
                    {
                        sum = SqlFunc.AggregateSum(it.Counter ?? 0)
                    }).First();
                if(res == null)
                {
                    return workOrder.PreviousNumber;
                }
                else
                {
                    return workOrder.PreviousNumber - res.sum;
                }
            }
            catch (Exception ex)
            {
                return 0;
            }
        }
        /// <summary>
        /// 工单已打印标签数
        /// </summary>
        /// <param name="workOrderId"></param>
        /// <returns></returns>
        public int GetWorkOrderPackingrecordCount(string workOrderId)
        {
            try
            {
                return Context.Queryable<WmPackingrecord>()
                        .Where(it => it.WorkOrderNum == workOrderId)
                        .OrderBy(it => it.Id)
                        .Count();
            }
            catch (Exception ex)
            {
                return 0;
            }
        }
        public QcCommonFqcBoardDto GetWorkOrderBoardData(string workOrderId)
        {
            try
            {
                // 检查对应工单是否存在
                ProWorkorder_v2 proWorkOrder = Context.Queryable<ProWorkorder_v2>().Where(it => it.ClientWorkorder == workOrderId).First();
                if (proWorkOrder == null)
                {
                    return null;
                }
                // 
                QcCommonFqcBoardDto boardData = new QcCommonFqcBoardDto();
                boardData.WorkOrderId = workOrderId;
                // 提取工单年周日,组成数组
                int year = proWorkOrder.Year;
                int week = proWorkOrder.Week;
                int date = proWorkOrder.Date;
                List<ProWorkorder_v2> proWorkorders = GenerateWorkOrderListUtil(year, week, date, 2);
                if (proWorkorders == null)
                {
                    return null;
                }
                boardData.WorkOrderDayListCount = proWorkorders.Count;
                // 提取目标工单号所在工单列表的位置
                for (int i = 0; i < proWorkorders.Count; i++)
                {
                    if (workOrderId == proWorkorders[i].ClientWorkorder)
                    {
                        boardData.WorkOrderIndex = i + 1; break;
                    }
                }
                boardData.WorkOrderPackageCount = GetWorkOrderNeedPackingTotal(workOrderId);
                boardData.WorkOrderFinishPackageNum = GetWorkOrderPackingrecordCount(workOrderId);
                boardData.WorkOrderNotFinishPackageNum = boardData.WorkOrderPackageCount - boardData.WorkOrderFinishPackageNum;
                // 如果不是第一个工单，找到上一个工单号
                if (boardData.WorkOrderIndex > 1)
                {
                    boardData.LastWorkOrderId = proWorkorders[(boardData.WorkOrderIndex - 2) ?? 0].ClientWorkorder;
                    boardData.LastWorkOrderPackageCount = GetWorkOrderNeedPackingTotal(boardData.LastWorkOrderId);
                    boardData.LastWorkOrderFinishPackageNum = GetWorkOrderPackingrecordCount(boardData.LastWorkOrderId);
                    boardData.LastWorkOrderNotFinishPackageNum = boardData.LastWorkOrderPackageCount - boardData.LastWorkOrderFinishPackageNum;
                }
                List<ProWorkorder_v2> finishWorkorders = GenerateWorkOrderListUtil(year, week, date, 1,2);
                if (finishWorkorders == null)
                {
                    return null;
                }
                boardData.WorkOrderFinishNum = finishWorkorders.Count;
                boardData.WorkOrderNotFinishNum = boardData.WorkOrderDayListCount - boardData.WorkOrderFinishNum;
                boardData.UpdatedTime = DateTime.Now;
                return boardData;
            }
            catch (Exception ex)
            {
                return null;
            }
        }
    }
}