using System;
using SqlSugar;
using Infrastructure.Attribute;
using DOAN.Model;

using DOAN.Model.MES.product;
using DOAN.Model.MES.product.Dto;

using DOAN.Repository;
using DOAN.Service.MES.product.IService;

using System.Linq;
using SqlSugar.Extensions;
using MimeKit.Tnef;
using DOAN.Model.MES.base_;
using Microsoft.AspNetCore.Http;
using DOAN.Model.System;
using MiniExcelLibs;
using NPOI.SS.Formula.Functions;
using NPOI.SS.UserModel;
using NPOI.XSSF.UserModel;
using System.Data.Common;
using NPOI.XWPF.UserModel;
using NPOI.HSSF.UserModel;
using Microsoft.AspNetCore.Components.Forms;
using System.Globalization;
using System.ComponentModel;
using NPOI.Util;
using DOAN.Model.MES.base_.Dto;
using Aliyun.OSS;
using DOAN.Model.MES.group;
using Mapster;
using Microsoft.AspNetCore.Authentication;

namespace DOAN.Service.MES.product
{
    /// <summary>
    /// 生产工单Service业务层处理
    /// </summary>
    [AppService(ServiceType = typeof(IProWorkorderService), ServiceLifetime = LifeTime.Transient)]
    public class ProWorkorderService : BaseService<ProWorkorder>, IProWorkorderService
    {
        /// <summary>
        /// 查询生产工单列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<ProWorkorderDto3> GetList(ProWorkorderQueryDto parm)
        {
            if (parm.WorkorderDate != null && parm.WorkorderDate.Length > 0)
            {
                parm.WorkorderDate[0] = parm.WorkorderDate[0].Date;
                parm.WorkorderDate[1] = parm.WorkorderDate[1].Date;

            }

            var predicate = Expressionable.Create<ProWorkorder>()
                .AndIF(!string.IsNullOrEmpty(parm.ProductionName), it => it.ProductionName.Contains(parm.ProductionName))
                .AndIF(!string.IsNullOrEmpty(parm.ProductionCode), it => it.ProductionCode.Contains(parm.ProductionCode))
                .AndIF(!string.IsNullOrEmpty(parm.CustomCode), it => it.CustomCode.Contains(parm.CustomCode))
                .AndIF(!string.IsNullOrEmpty(parm.FkRouteCode), it => it.FkRouteCode.Contains(parm.FkRouteCode))
                .AndIF(parm.WorkorderDate != null && parm.WorkorderDate[0] > DateTime.MinValue, it => it.WorkorderDate >= parm.WorkorderDate[0])
                .AndIF(parm.WorkorderDate != null && parm.WorkorderDate[1] > DateTime.MinValue, it => it.WorkorderDate <= parm.WorkorderDate[1])
                .AndIF(parm.Year > 0, it => it.Year == parm.Year)
                .AndIF(parm.Week > 0, it => it.Week == parm.Week)
                .AndIF(parm.Date > 0, it => it.Date == parm.Date)
                ;

            var query = Queryable()
                .Where(predicate.ToExpression());

            var query1 = Context.Queryable(query).LeftJoin<BaseMaterialList>((q, m) => q.ProductionCode == m.Code)
              .Select((q, m) => new ProWorkorderDto3()
              {

                  MaterialName = m.Name,

                  Specification = m.Specification,
                  Unit = q.Unit,
              }, true);
            var query2 = Context.Queryable(query1).LeftJoin<BaseWorkRoute>((q, r) => q.FkRouteCode == r.Code)
                 .Select((q, r) => new ProWorkorderDto3()
                 {
                     LackId = r.Id,

                 }, true);


            var response = query2.MergeTable().OrderBy(it => it.WorkorderDate).ToPage<ProWorkorderDto3, ProWorkorderDto3>(parm);




            return response;
        }


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

            return response;
        }

        /// <summary>
        /// 添加生产工单
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public ProWorkorder AddProWorkorder(ProWorkorder model)
        {
            model.Id = SnowFlakeSingle.Instance.NextId().ToString();

            return Context.Insertable(model).ExecuteReturnEntity();
        }

        /// <summary>
        /// 修改生产工单
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int UpdateProWorkorder(ProWorkorder model)
        {
            var response = Update(w => w.Id == model.Id, it => new ProWorkorder()
            {
                ProductionName = model.ProductionName,
                ProductionCode = model.ProductionCode,
                CustomCode = model.CustomCode,
                DeliveryNum = model.DeliveryNum,
                Unit = model.Unit,
                PackageNum = model.PackageNum,
                Sort = model.Sort,
                WorkorderDate = model.WorkorderDate,
                Year = model.Year,
                Week = model.Week,
                Date = model.Date,
                FkRouteCode = model.FkRouteCode,
                GroupId = model.GroupId,
                Priority = model.Priority,
                Status = model.Status,
                Remark = model.Remark,
                CreatedBy = model.CreatedBy,
                CreatedTime = model.CreatedTime,
                UpdatedBy = model.UpdatedBy,
                UpdatedTime = model.UpdatedTime,
            });
            return response;

        }


        /// <summary>
        /// 生成工单号
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public int Generate_workorder(ProWorkorderQueryDto2 parm)
        {
            DateTime update_time = parm.WorkorderDate.Date;

            List<ProWorkorder> proWorkorderList = Context.Queryable<ProWorkorder>().Where(it => it.WorkorderDate == update_time)
                  .Where(it => it.Status == 1)
                 .OrderBy(it => it.Sort).ToList();
            string maxs = Context.Queryable<ProWorkorder>().Where(it => it.WorkorderDate == update_time)
                   .Where(it => it.Status == 3).Max(it => it.Workorder);


            if (proWorkorderList != null && proWorkorderList.Count() > 0)
            {

                string baseSort = update_time.ToString("yyyyMMdd");
                int index = 1;
                if (!string.IsNullOrEmpty(maxs))
                {
                    index = Convert.ToInt32(maxs.Substring(maxs.Length - 3)) + 1;

                }

                foreach (ProWorkorder item in proWorkorderList)
                {
                    item.Workorder = baseSort + index.ToString("000");
                    item.Sort = index * 10;
                    index++;
                }
            }
            return Context.Updateable(proWorkorderList).ExecuteCommand();
        }


        /// <summary>
        /// 插入工单、新增工单
        /// </summary>
        /// <param name="proWorkorder"></param>
        /// <param name="next_id"></param>
        /// <returns></returns>
        /// 
        public int Insert_workOrder(ProWorkorder proWorkorder, string next_id)
        {
            int result = 0;
            proWorkorder.Id = XueHua;

            DateTime handleDate = proWorkorder.WorkorderDate.Value.ToLocalTime().Date;
            //插入工单
            if (!string.IsNullOrEmpty(next_id) && next_id != "-1")
            {
                UseTran2(() =>
                {
                    string maxs = Context.Queryable<ProWorkorder>().Where(it => it.WorkorderDate == handleDate)
                 .Where(it => it.Status == 3).Max(it => it.Workorder);
                    int index = 1;
                    if (!string.IsNullOrEmpty(maxs))
                    {
                        index = Convert.ToInt32(maxs.Substring(maxs.Length - 3)) + 1;

                    }
                    proWorkorder.Workorder = handleDate.ToString("yyyyMMdd") + index.ToString("000")+"K";
                    int sortNum = Context.Queryable<ProWorkorder>().Where(it => it.Id == next_id).Select(it => it.Sort.Value).First();
                    // 调整序号
                    Context.Updateable<ProWorkorder>()
                        .Where(it => it.WorkorderDate == handleDate)
                        .Where(it => it.Sort >= sortNum)
                        .SetColumns(it => new ProWorkorder() { Sort = it.Sort + 10 })
                        .ExecuteCommand();
                    proWorkorder.Sort = sortNum;
                    proWorkorder.Status = 1;

                    result=Context.Insertable(proWorkorder).ExecuteCommand();

                });
            }
            else
            {
                int sortNum = Context.Queryable<ProWorkorder>().Where(it => it.WorkorderDate == handleDate).Max(it => it.Sort.Value);

                proWorkorder.Sort = sortNum + 10;

                proWorkorder.Status = 1;

                result= Context.Insertable(proWorkorder).ExecuteCommand();

            }

            return result;

        }
        public int Insert_workOrder2(ProWorkorder proWorkorder, string next_id)
        {
            int result = 0;
            proWorkorder.Id = XueHua;
            proWorkorder.WorkorderDate = proWorkorder.WorkorderDate.Value.Date;
            if (!string.IsNullOrEmpty(next_id) && next_id != "-1")
            {
                UseTran2(() =>
                {

                    int sortNum = Context.Queryable<ProWorkorder>().Where(it => it.Id == next_id).Select(it => it.Sort.Value).First();
                    Context.Updateable<ProWorkorder>()
                        .Where(it => it.WorkorderDate == proWorkorder.WorkorderDate)
                        .Where(it => it.Sort >= sortNum)
                        .SetColumns(it => new ProWorkorder() { Sort = it.Sort + 10 })
                        .ExecuteCommand();


                    proWorkorder.Sort = sortNum;
                    proWorkorder.Status = 1;

                    Context.Insertable(proWorkorder).ExecuteCommand();

                });
            }
            else
            {
                DateTime dateOnly = proWorkorder.WorkorderDate.Value.Date;

                int sortNum = Context.Queryable<ProWorkorder>().Where(it => it.WorkorderDate == dateOnly).Max(it => it.Sort.Value);

                proWorkorder.Sort = sortNum + 10;

                proWorkorder.Status = 1;

                Context.Insertable(proWorkorder).ExecuteCommand();
            }



            Generate_workorder(new ProWorkorderQueryDto2()
            {
                WorkorderDate = proWorkorder.WorkorderDate.Value
            });

            return result;

        }


        /// <summary>
        /// 移动工单移动工单
        /// </summary>
        /// <param name="id"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public int MoveWorkorder(string id, int type)
        {
            int result = 0;
            ProWorkorder toMove = Context.Queryable<ProWorkorder>().Where(it => it.Id == id).First();
            var pervious = Context.Queryable<ProWorkorder>()
                  .Where(it => it.WorkorderDate == toMove.WorkorderDate);


            //上移动
            if (type == 1)
            {


                pervious = pervious.Where(it => it.Sort <= toMove.Sort).OrderByDescending(it => it.Sort);


            }
            //下移
            else if (type == 2)
            {


                pervious = pervious.Where(it => it.Sort >= toMove.Sort).OrderBy(it => it.Sort);
            }
            ProWorkorder exchange = pervious.Skip(1).Take(1).First();
            if (exchange != null)
            {
                int temp = toMove.Sort.Value;
                toMove.Sort = exchange.Sort;
                exchange.Sort = temp;
                result += Context.Updateable(toMove).ExecuteCommand();
                result += Context.Updateable(exchange).ExecuteCommand();

            }



            return result;

        }


        /// <summary>
        /// 导入工单
        /// </summary>
        /// <param name="formFile"></param>
        /// <returns></returns>
        public int ImportData2(IFormFile formFile, string username)
        {
            int result = 0;
            List<ProWorkorder> workorderList = new();
            DateTime dateValue = DateTime.MinValue;
            using (var stream = formFile.OpenReadStream())
            {
                IWorkbook workbook = new XSSFWorkbook(stream);
                ISheet sheet = workbook.GetSheetAt(0);
                // 处理第2行 获取日期

                IRow secondRow = sheet.GetRow(1);
                NPOI.SS.UserModel.ICell cell = secondRow.GetCell(0);


                // 将单元格的数字值转换为DateTime
                dateValue = cell.DateCellValue.Value;







                // 遍历每一行
                for (int row = 3; row <= sheet.LastRowNum; row++)
                {
                    IRow currentRow = sheet.GetRow(row);
                    if (currentRow != null) // 确保行不为空
                    {
                        ProWorkorder workorder = new ProWorkorder();
                        NPOI.SS.UserModel.ICell currentCell_01 = currentRow.GetCell(0);
                        workorder.ProductionCode = currentCell_01.ToString();

                        NPOI.SS.UserModel.ICell currentCell_02 = currentRow.GetCell(1);
                        workorder.ProductionName = currentCell_02.ToString();

                        NPOI.SS.UserModel.ICell currentCell_03 = currentRow.GetCell(2);
                        workorder.CustomCode = currentCell_03.ToString();

                        NPOI.SS.UserModel.ICell currentCell_04 = currentRow.GetCell(3);
                        workorder.Unit = currentCell_04.ToString();

                        NPOI.SS.UserModel.ICell currentCell_05 = currentRow.GetCell(4);
                        workorder.DeliveryNum = (int)currentCell_05.NumericCellValue;


                        NPOI.SS.UserModel.ICell currentCell_06 = currentRow.GetCell(5);
                        workorder.PackageNum = (int)currentCell_06.NumericCellValue;


                        NPOI.SS.UserModel.ICell currentCell_07 = currentRow.GetCell(6);
                        workorder.GroupId = (int)currentCell_07.NumericCellValue;


                        NPOI.SS.UserModel.ICell currentCell_08 = currentRow.GetCell(7);
                        workorder.FkRouteCode = currentCell_08.ToString();


                        NPOI.SS.UserModel.ICell currentCell_09 = currentRow.GetCell(8);
                        workorder.Remark = currentCell_09.StringCellValue;


                        workorderList.Add(workorder);

                    }
                }

            }
            List<ProWorkorder> updates = new();
            List<ProWorkorder> inserts = new();
            try
            {
                if (workorderList.Count > 0 && dateValue > DateTime.MinValue)
                {
                    List<ProWorkorder> Exists = Context.Queryable<ProWorkorder>().Where(it => it.WorkorderDate == dateValue).Where(it => it.Status == 0).ToList();

                    foreach (ProWorkorder item2 in workorderList)
                    {
                        int index = 0;
                        foreach (ProWorkorder item in Exists)
                        {
                            if (item.ProductionCode == item2.ProductionCode)
                            {
                                item2.Id = item.Id;
                                item2.UpdatedBy = username;
                                item2.UpdatedTime = DateTime.Now;
                                item2.WorkorderDate = dateValue;

                                item2.Year = dateValue.Year;

                                CultureInfo culture = CultureInfo.CurrentCulture;
                                item2.Week = culture.Calendar.GetWeekOfYear(dateValue, culture.DateTimeFormat.CalendarWeekRule, culture.DateTimeFormat.FirstDayOfWeek);
                                item2.Date = (int)dateValue.DayOfWeek;
                                updates.Add(item2);
                                index++;
                            }
                            continue;
                        }

                        if (index == 0)
                        {
                            item2.Id = XueHua;
                            item2.CreatedBy = username;
                            item2.CreatedTime = DateTime.Now;
                            item2.WorkorderDate = dateValue;
                            item2.Status = 1;
                            item2.Year = dateValue.Year;

                            CultureInfo culture = CultureInfo.CurrentCulture;
                            item2.Week = culture.Calendar.GetWeekOfYear(dateValue, culture.DateTimeFormat.CalendarWeekRule, culture.DateTimeFormat.FirstDayOfWeek);
                            item2.Date = (int)dateValue.DayOfWeek;
                            inserts.Add(item2);
                        }
                    }


                }
                if (inserts.Count > 0 || updates.Count > 0)
                {
                    UseTran2(() =>
                    {
                        //string[] codes = inserts.Select(it => it.ProductionCode).ToArray();
                        //Context.Deleteable<ProWorkorder>().Where(it => it.WorkorderDate == dateValue)
                        //.Where(it => it.Status == 0).Where(it => codes.Contains(it.ProductionCode))
                        //.ExecuteCommand();
                        result += Context.Insertable(inserts).ExecuteCommand();
                        result += Context.Updateable(updates).IgnoreColumns(true).ExecuteCommand();



                    });



                }

            }
            catch (Exception ex)
            {
                result = -1;

            }


            return result;
        }


        /// <summary>
        /// 导入工单  必须整删除 整改
        /// </summary>
        /// <param name="formFile"></param>
        /// <returns></returns>
        public int ImportData(IFormFile formFile, string username)
        {
            int result = 0;
            List<ProWorkorder> workorderList = new();
            DateTime dateValue = DateTime.MinValue;
            using (var stream = formFile.OpenReadStream())
            {
                IWorkbook workbook = new XSSFWorkbook(stream);
                ISheet sheet = workbook.GetSheetAt(0);
                // 处理第2行 获取日期

                IRow secondRow = sheet.GetRow(1);
                NPOI.SS.UserModel.ICell cell = secondRow.GetCell(0);


                // 将单元格的数字值转换为DateTime
                dateValue = cell.DateCellValue.Value;







                // 遍历每一行
                for (int row = 3; row <= sheet.LastRowNum; row++)
                {
                    IRow currentRow = sheet.GetRow(row);
                    if (currentRow != null) // 确保行不为空
                    {
                        ProWorkorder workorder = new ProWorkorder();
                        NPOI.SS.UserModel.ICell currentCell_01 = currentRow.GetCell(0);
                        workorder.ProductionCode = currentCell_01.ToString();

                        //NPOI.SS.UserModel.ICell currentCell_02 = currentRow.GetCell(1);
                        //workorder.ProductionName = currentCell_02.ToString();

                        //NPOI.SS.UserModel.ICell currentCell_03 = currentRow.GetCell(2);
                        //workorder.CustomCode = currentCell_03.ToString();
                        NPOI.SS.UserModel.ICell currentCell_05 = currentRow.GetCell(3);
                        workorder.CustomCode = currentCell_05.ToString();


                        //NPOI.SS.UserModel.ICell currentCell_04 = currentRow.GetCell(3);
                        //workorder.Unit = currentCell_04.ToString();




                        NPOI.SS.UserModel.ICell currentCell_06 = currentRow.GetCell(5);
                        workorder.DeliveryNum = (int)currentCell_06.NumericCellValue;


                        NPOI.SS.UserModel.ICell currentCell_07 = currentRow.GetCell(6);
                        workorder.PackageNum = (int)currentCell_07.NumericCellValue;


                        NPOI.SS.UserModel.ICell currentCell_08 = currentRow.GetCell(7);
                        workorder.GroupId = (int)currentCell_08.NumericCellValue;


                        NPOI.SS.UserModel.ICell currentCell_09 = currentRow.GetCell(8);
                        workorder.FkRouteCode = ((int)currentCell_09.NumericCellValue).ToString();

                        NPOI.SS.UserModel.ICell currentCell_010 = currentRow.GetCell(9);
                        workorder.Remark = currentCell_010.StringCellValue;

                        workorder.Id = XueHua;
                        workorder.CreatedBy = username;
                        workorder.CreatedTime = DateTime.Now;
                        workorder.WorkorderDate = dateValue;
                        workorder.Status = 1;
                        workorder.Year = dateValue.Year;

                        CultureInfo culture = CultureInfo.CurrentCulture;
                        workorder.Week = culture.Calendar.GetWeekOfYear(dateValue, culture.DateTimeFormat.CalendarWeekRule, culture.DateTimeFormat.FirstDayOfWeek);
                        workorder.Date = (int)dateValue.DayOfWeek;
                        workorderList.Add(workorder);

                    }
                }

            }
            UseTran2(() =>
            {

                Context.Deleteable<ProWorkorder>().Where(it => it.WorkorderDate == dateValue).ExecuteCommand();
                result = Context.Insertable(workorderList).ExecuteCommand();
            });
            return result;
        }
        /// <summary>
        /// 工单导出
        /// </summary>
        /// <param name="exportTime"></param>
        /// <param name="pager"></param>
        /// <returns></returns>
        public PagedInfo<ProWorkorder> WorkOrderExport(DateTime exportTime, PagerInfo pager)
        {
            exportTime = exportTime.Date;
            return Context.Queryable<ProWorkorder>().Where(it => it.WorkorderDate == exportTime).ToPage(pager);
        }

        /// <summary>
        /// 获取物料信息
        /// </summary>
        /// <param name="query"></param>
        /// <returns></returns>
        public List<BaseMaterialList> GetMaterialInfo(BaseMaterialListQueryDto5 parm)
        {
            var predicate = Expressionable.Create<BaseMaterialList>()
            .AndIF(!string.IsNullOrEmpty(parm.Name_or_Code), it => it.Name.Contains(parm.Name_or_Code))
            .AndIF(!string.IsNullOrEmpty(parm.Name_or_Code), it => it.Code.Contains(parm.Name_or_Code))
            ;

            return Context.Queryable<BaseMaterialList>()
             .Where(predicate.ToExpression()).Take(20).ToList();

        }

        /// <summary>
        /// 获取客户信息
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public List<BaseCustom> GetCustomInfo(BaseCustomQueryDto2 parm)
        {
            var predicate = Expressionable
              .Create<BaseCustom>()
              .AndIF(
                  !string.IsNullOrEmpty(parm.CustomNo),
                  it => it.CustomNo.Contains(parm.CustomNo)
              )
              //.AndIF(
              //    !string.IsNullOrEmpty(parm.CustomNo),
              //    it => it.CustomName.Contains(parm.CustomNo)
              //)
              .And(it => it.Status == 1);

            var response = Context.Queryable<BaseCustom>()
                .Where(predicate.ToExpression())
                .OrderBy(it => it.CustomNo)
                .Take(20)
                .ToList();
            return response;


        }


        /// <summary>
        /// 获取工艺路线
        /// </summary>
        /// <param name="dateTime"></param>
        /// <returns></returns>
        public List<BaseWorkRoute> GetProcessRoute(DateTime dateTime)
        {
            DateTime dataTO = dateTime.ToLocalTime().Date;
            var query = Context.Queryable<GroupSchedule>().Where(it => it.ScheduleDate == dataTO);

            return Context
                 .Queryable(query)
                 .LeftJoin<BaseWorkRoute>((q, p) => q.FkBelongRouteCode == p.Code)
                 .Select((q, p) => p)
                 .Distinct()
                 .ToList();
        }


        public List<BaseWorkRoute> GetAllRoute()
        {
            return Context.Queryable<BaseWorkRoute>().ToList();
        }


        /// <summary>
        /// 获取班组
        /// </summary>
        /// <param name="route_code"></param>
        /// <returns></returns>
        public List<GroupSchedule> GetGroupList(string route_code, DateTime dateTime)
        {
            dateTime = dateTime.ToLocalTime().Date;
            return Context.Queryable<GroupSchedule>().Where(it => it.FkBelongRouteCode == route_code)
                .Where(it => it.ScheduleDate == dateTime)
                .ToList();
        }



        /// <summary>
        /// 查询BOM 及其所需数量
        /// </summary>
        /// <param name="workorder_num"></param>
        /// <returns></returns>
        public List<WorkOrderBom> SearchBOMNum(string workorder_num)
        {
            List<BaseMaterialBom> baseMaterialBoms = null;
            ProWorkorder proworkorder = Context.Queryable<ProWorkorder>().Where(it => it.Workorder == workorder_num).First();
            if (proworkorder != null)
            {
                baseMaterialBoms = Context.Queryable<BaseMaterialBom>().Where(it => it.InvCode == proworkorder.ProductionCode).ToList();

                if (baseMaterialBoms != null && baseMaterialBoms
                    .Count() > 0)
                {
                    foreach (var item in baseMaterialBoms)
                    {
                        float num = float.Parse(item.Iusequantity) * proworkorder.DeliveryNum.Value;
                        item.Iusequantity = num.ToString();
                    }

                }


            }
            return baseMaterialBoms.Adapt<List<WorkOrderBom>>();


        }
    }


}