using Infrastructure.Attribute;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Reflection;
using ZR.Model;
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;
            }
        }

        public PagedInfo<QcCommonFqcWorkerOrderDataDto> GetWorkOrderFqcData(QcCommonFqcWorkerOrderDataQuery query)
        {
            try
            {
                // 时间解析 年 周（第几周） 日(星期) 转换
                int year = -1;
                int week = -1;
                int date = -1;
                if (query.StartTime != null)
                {
                    DateTime dateTime = query.StartTime ?? DateTime.Now;
                    GregorianCalendar gregorianCalendar = new GregorianCalendar();
                    year = gregorianCalendar.GetYear(dateTime);
                    week = gregorianCalendar.GetWeekOfYear(dateTime, CalendarWeekRule.FirstDay, DayOfWeek.Monday);
                    date = (int)gregorianCalendar.GetDayOfWeek(dateTime);
                    if (date == 0)
                    {
                        date = 7;
                    }
                }
                // 获取当天全部工单数据
                bool isCheckData = true;
                if (!string.IsNullOrEmpty(query.WorkOrderId))
                {
                    isCheckData = false;
                }
                var predicate = Expressionable.Create<ProWorkorder_v2>()
                                .AndIF(isCheckData, it => it.Year == year)
                                .AndIF(isCheckData, it => it.Week == week)
                                .AndIF(isCheckData, it => it.Date == date)
                                .And(it => it.Remark3 == "是")
                                .AndIF(query.Status > -1, it => it.Status == query.Status)
                                .AndIF(!string.IsNullOrEmpty(query.WorkOrderId), it => it.ClientWorkorder.Contains(query.WorkOrderId))
                                .AndIF(!string.IsNullOrEmpty(query.Partnumber), it => it.FinishedPartNumber.Contains(query.Partnumber))
                                .AndIF(!string.IsNullOrEmpty(query.Description), it => it.ProductDescription.Contains(query.Description) || it.Colour.Contains(query.Description) ||
                                it.Specifications.Contains(query.Description))
                                .ToExpression();
                List<ProWorkorder_v2> orderList = Context.Queryable<ProWorkorder_v2>()
                        .Where(predicate)
                        .OrderBy(it => it.Sort)
                        .ToList();

                //TODO 分页暂不实现

                //转换数据
                PagedInfo<QcCommonFqcWorkerOrderDataDto> resultPage = new PagedInfo<QcCommonFqcWorkerOrderDataDto>();
                List<QcCommonFqcWorkerOrderDataDto> resultList = new List<QcCommonFqcWorkerOrderDataDto>();
                foreach (var item in orderList)
                {
                    if (item != null)
                    {
                        string Remark = "";
                        WmMaterial material = Context.Queryable<WmMaterial>()
                            .Where(it => it.Partnumber == item.FinishedPartNumber)
                            .First();
                        string Description = "";
                        string Color = "";
                        string Specification = "";
                        if (material != null)
                        {
                            Description = material.Description;
                            Color = material.Color;
                            Specification = material.Specification;
                        }
                        else
                        {
                            Remark += "物料不在清单内 ";
                        }
                        // 首检报表数据拉取
                        QcQualityStatisticsFirst QcFirstData = Context.Queryable<QcQualityStatisticsFirst>()
                            .Where(it => it.WorkorderId == item.ClientWorkorder)
                            .First();
                        string Team = "";
                        DateTime? startTime = null;
                        DateTime? endTime = null;
                        if (QcFirstData != null)
                        {
                            Team = QcFirstData.Team;
                            startTime = QcFirstData.StartTime;
                            endTime = QcFirstData.EndTime;
                            if (startTime == null)
                            {
                                Remark += "工单开始时间为空 ";
                            }
                        }
                        int WorkOrderPackageCount = GetWorkOrderNeedPackingTotal(item.ClientWorkorder);
                        int WorkOrderFinishPackageNum = GetWorkOrderPackingrecordCount(item.ClientWorkorder);
                        int WorkOrderNotFinishPackageNum = WorkOrderPackageCount - WorkOrderFinishPackageNum;
                        if (WorkOrderNotFinishPackageNum < 0)
                        {
                            WorkOrderNotFinishPackageNum = 0;
                        }
                        bool IsFinish = WorkOrderNotFinishPackageNum == 0;

                        QcCommonFqcWorkerOrderDataDto newItem = new()
                        {
                            WorkOrderId = item.ClientWorkorder,
                            Partnumber = item.FinishedPartNumber,
                            Description = Description,
                            Color = Color,
                            Specification = Specification,
                            Team = Team,
                            StartTime = startTime,
                            EndTime = endTime,
                            Status = item.Status,
                            Remark = Remark,
                            IsFinish = IsFinish,
                            WorkOrderPackageCount = WorkOrderPackageCount,
                            WorkOrderFinishPackageNum = WorkOrderFinishPackageNum,
                            WorkOrderNotFinishPackageNum = WorkOrderNotFinishPackageNum
                        };
                        resultList.Add(newItem);
                    }
                }
                resultPage.Result = resultList;
                resultPage.TotalNum = resultPage.Result.Count;
                resultPage.PageSize = query.PageSize;
                resultPage.PageIndex = query.PageNum;
                return resultPage;
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
    }
}