using Aliyun.OSS;
using Infrastructure.Attribute;
using Infrastructure.Extensions;
using Infrastructure.Model;
using Microsoft.Data.SqlClient;
using RIZO.Model.Mes.Dto.WorkOrderInfo;
using RIZO.Model.Mes.MasterData;
using RIZO.Model.Mes.WorkOrderInfo;
using RIZO.Repository;
using RIZO.Service.Mes.IMesService.MasterData;
using RIZO.Service.Mes.IMesService.WorkOrderInfo;
using RIZO.Service.Mes.MasterData;
using MDM.Services.Process;
using MDM.Services.Material;
using SqlSugar;
using SqlSugar.Extensions;
using static System.Runtime.InteropServices.JavaScript.JSType;

namespace RIZO.Service.Mes.WorkOrderInfo
{
    /// <summary>
    /// 工单主表Service业务层处理
    /// </summary>
    [AppService(ServiceType = typeof(IWorkOrderService), ServiceLifetime = LifeTime.Transient)]
    public class WorkOrderService : BaseService<WorkOrder>, IWorkOrderService
    {
        private WorkOrderItemService workOrderItemService = new WorkOrderItemService();
        private MaterialListService materialListService = new MaterialListService();
        private ProcessRoutingService processRoutingService = new ProcessRoutingService();
        /// <summary>
        /// 查询工单主表列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<WorkOrderDto> GetList(WorkOrderQueryDto parm)
        {
            var predicate = QueryExp(parm);

            var response = Queryable()
                .Where(predicate.ToExpression())
                .ToPage<WorkOrder, WorkOrderDto>(parm);

            return response;
        }

        public PagedInfo<WorkOrderDto> GetListExport(WorkOrderQueryDto parm)
        {
            var predicate = QueryExpExport(parm);

            var response = Queryable()
                .Where(predicate.ToExpression())
                .ToPage<WorkOrder, WorkOrderDto>(parm);

            return response;
        }


        /// <summary>
        /// 获取详情
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        public WorkOrder GetInfo(long Id)
        {
            var response = Queryable()
                .Where(x => x.Id == Id)
                .First();

            return response;
        }

        /// <summary>
        /// 添加工单主表
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public WorkOrder AddWorkOrder(WorkOrder model)
        {
            return Insertable(model).ExecuteReturnEntity();
        }

        /// <summary>
        /// 修改工单主表
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int UpdateWorkOrder(WorkOrder model)
        {
            return Update(model, true);
        }

        /// <summary>
        /// 查询表达式
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        private static Expressionable<WorkOrder> QueryExp(WorkOrderQueryDto parm)
        {
            var predicate = Expressionable.Create<WorkOrder>();
            if (!string.IsNullOrWhiteSpace(parm.LineCode))
            {
                predicate.And(it => it.LineCode.Contains(parm.LineCode));
            }
            if (!string.IsNullOrWhiteSpace(parm.LineName))
            {
                predicate.And(it => it.LineName.Contains(parm.LineName));
            }
            if (!string.IsNullOrWhiteSpace(parm.WorkOrderCode))
            {
                predicate.And(it => it.WorkOrderCode.Contains(parm.WorkOrderCode));
            }
            if (!string.IsNullOrWhiteSpace(parm.OrderDate))
            {
                predicate.And(it => it.OrderDate.Contains(parm.OrderDate));
            }
            return predicate;
        }

        private static Expressionable<WorkOrder> QueryExpExport(WorkOrderQueryDto parm)
        {
            var predicate = Expressionable.Create<WorkOrder>();
            if (parm.StartTime != null && parm.StartTime.ToString().Length > 0)
            {
                predicate.And(it => it.CreateTime >= parm.StartTime);
            }
            if (parm.EndTime != null && parm.EndTime.ToString().Length > 0)
            {
                predicate.And(it => it.CreateTime < parm.EndTime);
            }
            return predicate;
        }


        public ApiResult CreateWorkOrderBySacnCode(FlowCard flowCard)
        {
            
            try
            {
                WorkOrder orderInfoNew = new WorkOrder();
                //if (string.IsNullOrWhiteSpace(json))
                //{
                //    return ApiResult.Error(400,"扫码数据为空，请重新扫码");
                //}
                //扫码信息转成FlowCard对象
                //假设扫码结果是json形式
                //{
                //    "FlowCardNo": "0001",
                //     "LineCode" : "001",
                //     "LineName" : "001",
                //    "MaterialCode": "GEAR-001",
                //    "MaterialName": "齿轮（A型）",
                //    "BatchNumber": "Batch-20251122-01",
                //    "TotalQty": 100
                //}
                //字符串转对象
                //FlowCard flowCard = new FlowCard();
                //try
                //{
                //    flowCard = JsonConvert.DeserializeObject<FlowCard>(json);
                //}
                //catch (Exception ex)
                //{
                //    return ApiResult.Error(400, "扫码数据格式错误，无法解析");
                //}

                //工艺路线防错
                //var routing =  processRoutingService.Queryable().Where(it => it.FkProductMaterialCode == flowCard.MaterialCode.Trim()).First();
                //if (routing != null)
                //{
                //    //目前情况是工艺路线与物料未绑定
                //    return ApiResult.Error(400, "零件编码：" + flowCard.MaterialCode + "与工艺路线未绑定，请先绑定");
                //}
                //else
                //{
                //    string strRouting = routing.RoutingCode.Trim();
                //    if (strRouting != flowCard.ProcessCode.Trim())
                //    {
                //        return ApiResult.Error(400, "零件编码：" + flowCard.MaterialCode + "的工艺路线是"+routing.RoutingName+"与所选工艺路线不一致，请重新选择工艺路线");
                //    }
                //}

                //看扫流卡码能否得到一个唯一的流卡编码，若得不到则自己生产202511280001
                string strDay = DateTime.Now.ToString("yyyyMMdd");
                int Sequcence = 1;
                WorkOrder item = Queryable()
                    .Where(it => it.WorkOrderCode.Contains(strDay)).OrderByDescending(it => it.Sequcence).First();
                if (item != null)
                {
                    Sequcence = item.Sequcence;
                    Sequcence += 1;
                }
                string formattedSequence = Sequcence.ToString("D4");
                string strWorkOrderCode = "WO"+strDay+ formattedSequence;
                //检验流卡二维码生成的工单是否重复生成
                var WorkOrder = Queryable()
                    .Where(it => it.FlowCardNo == flowCard.FlowCardNo).First(); ;
                if (WorkOrder == null)
                {
                    orderInfoNew.WorkOrderCode = strWorkOrderCode;
                    orderInfoNew.FlowCardNo = flowCard.FlowCardNo;
                    orderInfoNew.MaterialCode = flowCard.MaterialCode;
                    orderInfoNew.MaterialName = flowCard.MaterialName;
                    orderInfoNew.BatchNumber = flowCard.BatchNumber;
                    orderInfoNew.TotalQty = flowCard.TotalQty;
                    orderInfoNew.LineCode = flowCard.LineCode;
                    orderInfoNew.LineName = flowCard.LineName;
                    orderInfoNew.OrderDate = strDay;
                    //orderInfoNew.ProcessCode = flowCard.ProcessCode;
                    //orderInfoNew.ProcessName = flowCard.ProcessName;
                    orderInfoNew.OrderStatus = 1;
                    orderInfoNew.CreateBy = flowCard.UserId;
                    orderInfoNew.CreateName = flowCard.UserName;
                    orderInfoNew.UpdateBy = flowCard.UserId;
                    orderInfoNew.UpdateName = flowCard.UserName;
                    orderInfoNew.CreateTime = DateTime.Now;
                    orderInfoNew.UpdateTime = DateTime.Now;
                    int iFlag = Insert(orderInfoNew);
                    if (iFlag > 0)
                    {
                        return ApiResult.Success(orderInfoNew);
                    }
                    else
                    {
                        return ApiResult.Error("工单创建失败" );
                    }
                }
                else
                {
                    return ApiResult.Success(WorkOrder);
                }
            }
            catch (Exception ex)
            {
                return ApiResult.Error("工单创建失败"+ex.ToString());
            }
        }

        /// <summary>
        /// OrderStatus 1执行中，2已完成
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public int ChangeWorkOrderState(WorkOrderState parm)
        {
            int iResult = 0;
            try
            {
                iResult = Update(where: it => it.Id == parm.Id,
                     columns: it => new WorkOrder
                     {
                         OrderStatus = parm.OrderStatus,       // 目标状态
                         UpdateBy = parm.UserId,               // 更新人ID
                         UpdateName = parm.UserName,           // 更新人名称
                         UpdateTime = DateTime.Now             // 更新时间
                     }
                 );
            }
            catch (Exception ex)
            {
                iResult = 0;
            }
            return iResult;
        }

        /// <summary>
        /// 按产线统计7天内每日合格率（折线图数据）
        /// </summary>
        /// <returns>合格率折线图格式（xAxisData + series）</returns>
        public ChartResponse QueryQualityLineChart()
        {
            DateTime now = DateTime.Now;
            List<DateTime> last7Days = Enumerable.Range(0, 7)
                .Select(i => now.AddDays(-i).Date)
                .OrderBy(date => date)
                .ToList();
            List<string> xAxisData = last7Days.Select(date => date.ToString("yyyy-MM-dd")).ToList();
            string sqlLine7 = @"SELECT DISTINCT
              w.line_code LineCode,
              w.line_name LineName
            FROM
              work_order w
            WHERE
              w.create_time >= DATE_SUB(CURDATE(), INTERVAL 6 DAY)
              AND w.create_time < DATE_ADD(CURDATE(), INTERVAL 1 DAY)";
            var queryDataLine7 = SqlQueryToList(sqlLine7);
            string sql = string.Format(@"SELECT
              w.line_code LineCode,
              w.line_name LineName,
              w.create_time,
              sum(w.ok_qty) OkQty,
              sum(w.ng_qty) NgQty
            FROM
              work_order w
            WHERE
              w.create_time >= DATE_SUB(CURDATE(), INTERVAL 6 DAY)
              AND w.create_time < DATE_ADD(CURDATE(), INTERVAL 1 DAY)
            GROUP BY
              w.line_code,
              w.line_name,
              DATE_FORMAT(w.create_time, '%Y-%m-%d')");
            var queryData = SqlQueryToList(sql);
            List<ChartSeries> series = new List<ChartSeries>();
            foreach (var lineItem in queryDataLine7)
            {
                string lineCode = lineItem.LineCode;
                string lineName = lineItem.LineName;
                List<double> rateData = new List<double>(); 

                // 遍历7天日期，逐一匹配数据
                foreach (string date in xAxisData)
                {
                    var listResult = queryData.Where(it => it.LineCode == lineCode).ToList();
                    double rate = 0.0;
                    foreach(var item in listResult)
                    {
                        if (item.CreateTime.ObjToDate().ToString("yyyy-MM-dd").Contains(date))
                        {
                            int okQty = 0;
                            if (item.OkQty != null)
                            {
                                okQty = item.OkQty;
                            }
                            int ngQty = 0;
                            if (item.NgQty != null)
                            {
                                ngQty = item.NgQty;
                            }
                            int total = okQty + ngQty;

                            rate = total == 0 ? 0.0 : Math.Round(((double)okQty / total) * 100, 2);
                        }
                    }
                    rateData.Add(rate);
                }
                series.Add(new ChartSeries
                {
                    Name = $"{lineName}（{lineCode}）",
                    Data = rateData
                });
            }
            return new ChartResponse
            {
                xAxisData = xAxisData,
                series = series
            };
        }

        public ChartResponse QueryQualityBarChart()
        {
            DateTime now = DateTime.Now;
            List<DateTime> last7Days = Enumerable.Range(0, 7)
                .Select(i => now.AddDays(-i).Date)
                .OrderBy(date => date)
                .ToList();
            List<string> xAxisData = last7Days.Select(date => date.ToString("yyyy-MM-dd")).ToList();
            string sql = string.Format(@"SELECT
              w.create_time,
              sum(w.ok_qty) OkQty,
              sum(w.ng_qty) NgQty
            FROM
              work_order w
            WHERE
              w.create_time >= DATE_SUB(CURDATE(), INTERVAL 6 DAY)
              AND w.create_time < DATE_ADD(CURDATE(), INTERVAL 1 DAY)
            GROUP BY
              DATE_FORMAT(w.create_time, '%Y-%m-%d')");
            var queryData = SqlQueryToList(sql);
            List<ChartSeries> series = new List<ChartSeries>();
            // 为7天的每个日期补全数据，计算合格率
            List<double> dataOk = new List<double>();
            List<double> dataNG = new List<double>();

            foreach (string date in xAxisData)
            {
                double okNum = 0.0;
                double ngNum = 0.0;
                foreach (var lineKv in queryData)
                {
                    if (lineKv.CreateTime.ObjToDate().ToString("yyyy-MM-dd").Contains(date))
                    {
                        if (lineKv.OkQty != null)
                        {
                            okNum = lineKv.OkQty;
                        }
                        if (lineKv.NgQty != null)
                        {
                            ngNum = lineKv.NgQty;
                        }
                    }
                }
                dataOk.Add(okNum);
                dataNG.Add(ngNum);
            }
            series.Add(new ChartSeries
            {
                Name = $"合格数",
                Data = dataOk
            });
            series.Add(new ChartSeries
            {
                Name = $"不合格数",
                Data = dataNG
            });
            return new ChartResponse
            {
                xAxisData = xAxisData,
                series = series
            };
        }

        public List<WorkOrder> QueryWorkOrderMonth()
        {
            List<WorkOrder> workOrders = Queryable()
                .Where(it => it.CreateTime <= DateTime.Now && it.CreateTime >= DateTime.Now.AddDays(-30)).ToList();
            return workOrders;
        }

        public ApiResult QueryWorkOrderToDay()
        {
            try
            {
                var today = DateTime.Today;
                DateTime startTime = new DateTime(today.Year, today.Month, today.Day, 0, 0, 0);
                DateTime endTime = new DateTime(today.Year, today.Month, today.Day, 23, 59, 59);
                List<WorkOrder> workOrders = Queryable()
                .Where(it => it.CreateTime <= endTime && it.CreateTime >= startTime)
                .ToList();
                if (workOrders.Any())
                {
                    return ApiResult.Success(workOrders);
                }
                else
                {

                    return new ApiResult(201, "无工单数据");
                }
            }
            catch (Exception ex)
            {
                return ApiResult.Error(ex.Message);
            }
        }
    }
}