using Infrastructure.Attribute;
using SqlSugar;
using System;
using System.Linq;
using System.Text.RegularExpressions;
using ZR.Model;
using ZR.Model.Business;
using ZR.Model.MES.pro;
using ZR.Model.MES.qc;
using ZR.Model.MES.wms;
using ZR.Model.MES.wms.Dto;
using ZR.Repository;
using ZR.Service.mes.wms.IService;

namespace ZR.Service.mes.wms
{
    /// <summary>
    /// 一次合格品仓库记录表Service业务层处理
    /// </summary>
    [AppService(
        ServiceType = typeof(IWmOneTimeRecordService),
        ServiceLifetime = LifeTime.Transient
    )]
    public class WmOneTimeRecordService : BaseService<WmOneTimeRecord>, IWmOneTimeRecordService
    {
        /// <summary>
        /// 查询一次合格品仓库记录表列表
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public PagedInfo<WmOneTimeRecordDto> GetList(WmOneTimeRecordQueryDto parm)
        {
            var predicate = Expressionable
                .Create<WmOneTimeRecord>()
                .AndIF(
                    !string.IsNullOrEmpty(parm.Partnumber),
                    it => it.Partnumber == parm.Partnumber
                )
                .AndIF(!string.IsNullOrEmpty(parm.Remark), it => it.Remark.Contains(parm.Remark))
                .AndIF(!string.IsNullOrEmpty(parm.Code), it => it.Code.Contains(parm.Code))
                /*.AndIF(
                    !string.IsNullOrEmpty(parm.FkInventoryId),
                    it => it.FkInventoryId == parm.FkInventoryId
                )*/
                .AndIF(!string.IsNullOrEmpty(parm.Id), it => it.Id == parm.Id)
                .AndIF(parm.ChangeType > -1, it => it.ChangeType == parm.ChangeType)
                .AndIF(
                    parm.StartActionTime != null,
                    it => parm.StartActionTime.Value.ToLocalTime() <= it.ActionTime
                )
                .AndIF(
                    parm.EndActionTime != null,
                    it => parm.EndActionTime.Value.ToLocalTime() >= it.ActionTime
                );

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

            return response;
        }

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

            return response;
        }

        /// <summary>
        /// 添加一次合格品仓库记录表
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public WmOneTimeRecord AddWmOneTimeRecord(WmOneTimeRecord model)
        {
            return Context.Insertable(model).ExecuteReturnEntity();
        }

        /// <summary>
        /// 修改一次合格品仓库记录表
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public int UpdateWmOneTimeRecord(WmOneTimeRecord model)
        {
            //var response = Update(w => w.Id == model.Id, it => new WmOneTimeRecord()
            //{
            //    Code = model.Code,
            //    Partnumber = model.Partnumber,
            //    BlankNum = model.BlankNum,
            //    ChangeType = model.ChangeType,
            //    ChangeQuantity = model.ChangeQuantity,
            //    ActionTime = model.ActionTime,
            //    Status = model.Status,
            //    Remark = model.Remark,
            //    CreatedBy = model.CreatedBy,
            //    CreatedTime = model.CreatedTime,
            //    UpdatedBy = model.UpdatedBy,
            //    UpdatedTime = model.UpdatedTime,
            //});
            //return response;
            return Update(model, true);
        }

        /// <summary>
        /// 自动生成一次合格仓库记录日志
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        /// <exception cref="global::System.NotImplementedException"></exception>
        public int GenerateWmOneTimeRecord(WmOneTimeRecordGenerateDto parm)
        {
            if (parm == null || parm.StartTime == null || parm.StartTime.Value == DateTime.MinValue)
            {
                return -1;
            }
            else
            {
                #region 查询需要的数据
                //TODO 入库条件1 产线合格品qc_quality_statistics_first，合格数，其中去除（倒车雷达）
                List<QcQualityStatisticsFirst> qcQualityStatisticsFirsts = Context
                    .Queryable<QcQualityStatisticsFirst>()
                    .WhereIF(
                        !string.IsNullOrEmpty(parm.Partnumber),
                        it => it.FinishedPartNumber == parm.Partnumber
                    )
                    .Where(it => !it.ProductDescription.Contains("倒车雷达"))
                    .Where(it => it.StartTime >= parm.StartTime)
                    .Where(it => it.QualifiedNumber > 0)
                    .Where(it => it.Remark == "抛光")
                    .ToList();

                //TODO 入库条件2 抛光合格品 wm_polish_work_quality_statistics 合格数
                List<WmPolishWorkQualityStatistics> wmPolishWorkQualityStatistics = Context
                    .Queryable<WmPolishWorkQualityStatistics>()
                    .WhereIF(
                        !string.IsNullOrEmpty(parm.Partnumber),
                        it => it.Partnumber == parm.Partnumber
                    )
                    .Where(it => it.StartTime >= parm.StartTime)
                    .ToList();

                //TODO 出库条件1 GP12 （新） 触摸屏  qc_gp12_service_statistics 投入数
                List<QcGp12ServiceStatistics> qcGp12ServiceStatistics = Context
                    .Queryable<QcGp12ServiceStatistics>()
                    .WhereIF(
                        !string.IsNullOrEmpty(parm.Partnumber),
                        it => it.PartNumber == parm.Partnumber
                    )
                    .Where(it => it.StartTime >= parm.StartTime)
                    .Where(it => it.GroupSort == 1)
                    .ToList();

                //TODO 出库条件2 后道 wm_polish_quality_statistics 投入数
                List<WmPolishQualityStatistics> wmPolishQualityStatistics = Context
                    .Queryable<WmPolishQualityStatistics>()
                    .WhereIF(
                        !string.IsNullOrEmpty(parm.Partnumber),
                        it => it.Partnumber == parm.Partnumber
                    )
                    .Where(it => it.StartTime >= parm.StartTime)
                    .ToList();

                #endregion

                #region 组装 WmOneTimeRecord 实体

                List<WmOneTimeRecord> wmOneTimeRecords = new List<WmOneTimeRecord>();

                foreach (var item in qcQualityStatisticsFirsts)
                {
                    wmOneTimeRecords.Add(
                        new WmOneTimeRecord
                        {
                            Id = SnowFlakeSingle.Instance.NextId().ToString(),
                            FkInventoryId = item.Id,
                            Code = "自动",
                            Partnumber = item.FinishedPartNumber,
                            ChangeType = 1,
                            ChangeQuantity = item.QualifiedNumber,
                            ActionTime = item.StartTime,
                            Status = 1,
                            Remark = "产线报表合格品自动入库,来源工单号:" + item.WorkorderId
                        }
                    );
                }

                foreach (var item in wmPolishWorkQualityStatistics)
                {
                    wmOneTimeRecords.Add(
                        new WmOneTimeRecord
                        {
                            Id = SnowFlakeSingle.Instance.NextId().ToString(),
                            FkInventoryId = item.Id,
                            Code = "自动",
                            Partnumber = item.Partnumber,
                            ChangeType = 1,
                            ChangeQuantity = item.QualifiedNumber,
                            ActionTime = item.StartTime,
                            Status = 1,
                            Remark = "抛光报表合格品自动入库"
                        }
                    );
                }

                foreach (var item in qcGp12ServiceStatistics)
                {
                    wmOneTimeRecords.Add(
                        new WmOneTimeRecord
                        {
                            Id = SnowFlakeSingle.Instance.NextId().ToString(),
                            FkInventoryId = item.Id,
                            Code = "自动",
                            Partnumber = item.PartNumber,
                            ChangeType = 2,
                            ChangeQuantity = item.RequireNumber,
                            ActionTime = item.StartTime,
                            Status = 1,
                            Remark = "GP12触摸屏报表投入自动出库"
                        }
                    );
                }

                foreach (var item in wmPolishQualityStatistics)
                {
                    wmOneTimeRecords.Add(
                        new WmOneTimeRecord
                        {
                            Id = SnowFlakeSingle.Instance.NextId().ToString(),
                            FkInventoryId = item.Id,
                            Code = "自动",
                            Partnumber = item.Partnumber,
                            ChangeType = 2,
                            ChangeQuantity = item.RequireNumber,
                            ActionTime = item.StartTime,
                            Status = 1,
                            Remark = "后道报表自动出库"
                        }
                    );
                }

                #endregion

                //如果有这个时间段的数据，要删除
                List<WmOneTimeRecord> delwmOneTimeRecords = Context
                    .Queryable<WmOneTimeRecord>()
                    .Where(it => it.Code == "自动")
                    .Where(it => it.ActionTime >= parm.StartTime)
                    .ToList();
                Context.Deleteable(delwmOneTimeRecords).ExecuteCommand();
                if (wmOneTimeRecords.Any())
                {
                    Context.Insertable(wmOneTimeRecords).ExecuteCommand();
                }

                return wmOneTimeRecords.Count; // 返回插入的记录数
            }
        }

        /// <summary>
        /// 自动生成一次合格仓库记录日志 （后道自动化版本）
        /// </summary>
        /// <param name="parm"></param>
        /// <returns></returns>
        public int GenerateWmOneTimeRecord02(WmOneTimeRecordGenerateDto parm)
        {
            if (parm == null || parm.StartTime == null || parm.StartTime.Value == DateTime.MinValue)
            {
                return -1;
            }
            int result = 0;
            try
            {
                // 开始事务
                Context.Ado.BeginTran();

                #region 查询需要的数据
                // 入库条件1 产线合格品qc_quality_statistics_first，合格数，其中去除（倒车雷达）
                List<QcQualityStatisticsFirst> qcQualityStatisticsFirsts = Context
                    .Queryable<QcQualityStatisticsFirst>()
                    .LeftJoin<ProWorkorder_v2>((qsf, wo) => qsf.WorkorderId == wo.ClientWorkorder)
                    .WhereIF(
                        !string.IsNullOrEmpty(parm.Partnumber),
                        (qsf, wo) => qsf.FinishedPartNumber == parm.Partnumber
                    )
                    .Where((qsf, wo) => !qsf.ProductDescription.Contains("倒车雷达"))
                    .Where((qsf, wo) => qsf.StartTime >= parm.StartTime)
                    .Where((qsf, wo) => qsf.QualifiedNumber > 0)
                    .Where((qsf, wo) => qsf.Remark == "抛光")
                    //XXX过滤维修件
                    //.Where((qsf, wo) => wo != null || !wo.Remark1.Contains("维修"))
                    .ToList();

                // 入库条件2 抛光合格品 wm_polish_work_quality_statistics 合格数
                List<WmPolishWorkQualityStatistics> wmPolishWorkQualityStatistics = Context
                    .Queryable<WmPolishWorkQualityStatistics>()
                    .WhereIF(
                        !string.IsNullOrEmpty(parm.Partnumber),
                        it => it.Partnumber == parm.Partnumber
                    )
                    .Where(it => it.StartTime >= parm.StartTime)
                    .ToList();

                // 出库条件1 GP12 （新） 触摸屏  qc_gp12_service_statistics 投入数
                List<QcGp12ServiceStatistics> qcGp12ServiceStatistics = Context
                    .Queryable<QcGp12ServiceStatistics>()
                    .WhereIF(
                        !string.IsNullOrEmpty(parm.Partnumber),
                        it => it.PartNumber == parm.Partnumber
                    )
                    .Where(it => it.StartTime >= parm.StartTime)
                    .Where(it => it.GroupSort == 1)
                    .ToList();

                // 出库条件2 后道 wm_polish_quality_statistics 投入数
                List<QcBackEndServiceStatistics> qcBackEndQualityStatistics = Context
                    .Queryable<QcBackEndServiceStatistics>()
                    .WhereIF(
                        !string.IsNullOrEmpty(parm.Partnumber),
                        it => it.PartNumber == parm.Partnumber
                    )
                    .Where(it => it.StartTime >= parm.StartTime)
                    .Where(it => it.GroupSort == 1)
                    // .Where(it => it.IsOut == 1) 待定 现在暂时都是直接出库
                    .ToList();
                List<WmPolishQualityStatistics> wmPolishQualityStatistics = Context
                    .Queryable<WmPolishQualityStatistics>()
                    .WhereIF(
                        !string.IsNullOrEmpty(parm.Partnumber),
                        it => it.Partnumber == parm.Partnumber
                    )
                    .Where(it => it.StartTime >= parm.StartTime)
                    .ToList();
                #endregion

                #region 组装 WmOneTimeRecord 实体
                List<WmOneTimeRecord> wmOneTimeRecords = new List<WmOneTimeRecord>();

                foreach (var item in qcQualityStatisticsFirsts)
                {
                    // TODO 零件号二次处理
                    string partNumber = item.FinishedPartNumber;
                    // 使用正则表达式匹配并移除特殊后缀
                    string processedPartnumber = Regex.Replace(
                        partNumber,
                        @"-(FL|FR|RR|RL)$",
                        "",
                        RegexOptions.IgnoreCase
                    );
                    wmOneTimeRecords.Add(
                        new WmOneTimeRecord
                        {
                            Id = SnowFlakeSingle.Instance.NextId().ToString(),
                            FkInventoryId = item.Id,
                            Code = "自动",
                            Partnumber = processedPartnumber,
                            ChangeType = 1,
                            ChangeQuantity = item.QualifiedNumber,
                            ActionTime = item.StartTime,
                            Status = 1,
                            Remark = "产线-报表合格品自动入库,来源工单号:" + item.WorkorderId
                        }
                    );
                }

                foreach (var item in wmPolishWorkQualityStatistics)
                {
                    // TODO 零件号二次处理
                    string partNumber = item.Partnumber;
                    // 使用正则表达式匹配并移除特殊后缀
                    string processedPartnumber = Regex.Replace(
                        partNumber,
                        @"-(FL|FR|RR|RL)$",
                        "",
                        RegexOptions.IgnoreCase
                    );
                    wmOneTimeRecords.Add(
                        new WmOneTimeRecord
                        {
                            Id = SnowFlakeSingle.Instance.NextId().ToString(),
                            FkInventoryId = item.Id,
                            Code = "自动",
                            Partnumber = processedPartnumber,
                            ChangeType = 1,
                            ChangeQuantity = item.QualifiedNumber,
                            ActionTime = item.StartTime,
                            Status = 1,
                            Remark = "抛光-报表合格品自动入库"
                        }
                    );
                }

                foreach (var item in qcGp12ServiceStatistics)
                {
                    // TODO 零件号二次处理
                    string partNumber = item.PartNumber;
                    // 使用正则表达式匹配并移除特殊后缀
                    string processedPartnumber = Regex.Replace(
                        partNumber,
                        @"-(FL|FR|RR|RL)$",
                        "",
                        RegexOptions.IgnoreCase
                    );
                    wmOneTimeRecords.Add(
                        new WmOneTimeRecord
                        {
                            Id = SnowFlakeSingle.Instance.NextId().ToString(),
                            FkInventoryId = item.Id,
                            Code = "自动",
                            Partnumber = processedPartnumber,
                            ChangeType = 2,
                            ChangeQuantity = item.RequireNumber,
                            ActionTime = item.StartTime,
                            Status = 1,
                            Remark = "GP12触摸屏-报表投入自动出库"
                        }
                    );
                }

                foreach (var item in qcBackEndQualityStatistics)
                {
                    // TODO 零件号二次处理
                    string partNumber = item.PartNumber;
                    // 使用正则表达式匹配并移除特殊后缀
                    string processedPartnumber = Regex.Replace(
                        partNumber,
                        @"-(FL|FR|RR|RL)$",
                        "",
                        RegexOptions.IgnoreCase
                    );
                    wmOneTimeRecords.Add(
                        new WmOneTimeRecord
                        {
                            Id = SnowFlakeSingle.Instance.NextId().ToString(),
                            FkInventoryId = item.Id,
                            Code = "自动",
                            Partnumber = processedPartnumber,
                            ChangeType = 2,
                            ChangeQuantity = item.RequireNumber,
                            ActionTime = item.StartTime,
                            Status = 1,
                            Remark = "后道触摸屏-报表自动出库"
                        }
                    );
                }
                //XXX 20250613 后道触摸屏与手填报表同时统计
                foreach (var item in wmPolishQualityStatistics)
                {
                    // TODO 零件号二次处理
                    string partNumber = item.Partnumber;
                    // 使用正则表达式匹配并移除特殊后缀
                    string processedPartnumber = Regex.Replace(
                        partNumber,
                        @"-(FL|FR|RR|RL)$",
                        "",
                        RegexOptions.IgnoreCase
                    );
                    wmOneTimeRecords.Add(
                        new WmOneTimeRecord
                        {
                            Id = SnowFlakeSingle.Instance.NextId().ToString(),
                            FkInventoryId = item.Id,
                            Code = "自动",
                            Partnumber = processedPartnumber,
                            ChangeType = 2,
                            ChangeQuantity = item.RequireNumber,
                            ActionTime = item.StartTime,
                            Status = 1,
                            Remark = "后道报表-手填报表出库"
                        }
                    );
                }
                #endregion

                // 直接删除旧数据，避免先查询再删除的并发问题
                Context
                    .Deleteable<WmOneTimeRecord>()
                    .Where(it => it.Code == "自动")
                    .Where(it => it.ActionTime >= parm.StartTime)
                    .ExecuteCommand();

                if (wmOneTimeRecords.Any())
                {
                    // 分批插入数据，避免一次插入过多数据
                    const int batchSize = 1000;
                    var batches = wmOneTimeRecords.Chunk(batchSize);

                    foreach (var batch in batches)
                    {
                        Context.Insertable(batch.ToList()).ExecuteCommand();
                    }
                }

                result = wmOneTimeRecords.Count;
                Context.Ado.CommitTran();
                return result; // 返回插入的记录数
            }
            catch (Exception)
            {
                Context.Ado.RollbackTran();
                return -1;
            }
        }
    }
}