using AutoMapper;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Text;
using wms.dataservice.IDataSetvice;
using wms.dto;
using wms.dto.request.fj;
using wms.dto.response;
using wms.dto.response.fj;
using wms.service.IService;
using wms.sqlsugar;
using wms.sqlsugar.model;
using wms.sqlsugar.model.fj;
using wms.util.Ext;
using System.Linq;
using WCS.Entity.fj;
using wms.util.Check;

namespace wms.service.Service
{
    public class FJService : IFJService
    {
        private readonly IMapper _mapper;
        private readonly ILogger<FJService> _logger;
        private readonly IFJDataService _IFJDataService;
 
        public FJService(IMapper mapper, ILogger<FJService> logger, IFJDataService IFJDataService)
        {
            _mapper = mapper;
            _logger = logger;
            _IFJDataService = IFJDataService;
        }
        Repository<fjBillDocument> _docrepository => new Repository<fjBillDocument>();
        Repository<fjSysConfig> _sysconfigrepository => new Repository<fjSysConfig>();
        Repository<fjBaseMater> _materrepository => new Repository<fjBaseMater>();
        Repository<fjBillTask> _billTaskrepository => new Repository<fjBillTask>();
        Repository<fjBaseWarehouse> _baseWareHouserepository => new Repository<fjBaseWarehouse>();
        Repository<fjBillBarcode> _billBarcoderepository => new Repository<fjBillBarcode>();
        Repository<fjBillFeedbackPush> _billFbackPushrepository => new Repository<fjBillFeedbackPush>();
        Repository<fjBillBomInfo> _fjBillBomInfoRepository => new Repository<fjBillBomInfo>();
        Repository<fjBillWetStack> _fjBillWetStackRepository => new Repository<fjBillWetStack>();

        ITenant _db => SqlSugarHelper.Db;//处理事务
        Repository<BaseContinfo> _baseContinfo => new Repository<BaseContinfo>();
        RepositoryTask<WCS_TaskInfo> _taskrepository => new RepositoryTask<WCS_TaskInfo>();

        Repository<BillInvnow> _billInvnowrepository => new Repository<BillInvnow>();
        Repository<BillInvinit> _billInvinitrepository => new Repository<BillInvinit>();
        Repository<BaseMatinfo> _basematerrepository => new Repository<BaseMatinfo>();
        Repository<BillSpoolTrans> _billSpoolTransrepository => new Repository<BillSpoolTrans>();
        Repository<BillBominfo> _billBominfoRepository => new Repository<BillBominfo>();
        Repository<BillBomsetinfo> _billBomsetinfoRepository => new Repository<BillBomsetinfo>();
  
        Repository<BillDocsinfo> _billdocrepository => new Repository<BillDocsinfo>();
        RepositoryTask<WCS_TaskOld> _wcstaskoldrepository => new RepositoryTask<WCS_TaskOld>();
        Repository<BillInvflow> _billInvflow => new Repository<BillInvflow>();
        Repository<BillPushinfo> _billPushinforepository => new Repository<BillPushinfo>();
        Repository<BaseWarecell> _basewarecellrepository => new Repository<BaseWarecell>();
        Repository<BaseWarehouse> _basewarehouserepository => new Repository<BaseWarehouse>();
        RepositoryTask<WCS_TaskDtl> _taskdetailrepository => new RepositoryTask<WCS_TaskDtl>();

        Repository<BillMachinfo> _basemachinforepository => new Repository<BillMachinfo>();



        /// <summary>
        /// 添加单据
        /// </summary>
        /// <returns></returns>
        public bool Add(fjBillDocument data1)
        {
            try
            {
                _db.BeginTran();
                _docrepository.Insert(data1);
                _db.CommitTran();
            }
            catch (Exception)
            {
                _db.RollbackTran();
                throw;
            }
            return true;
        }
        /// <summary>
        /// 获取配置内容信息
        /// </summary>
        /// <param name="code">配置表code值</param>
        /// <returns></returns>
        public string GetSysConfigContentByCode(string code)
        {
            //先读缓存
            var cacheContent = RedisHelper.Get("sys_config" + code);
            if (!string.IsNullOrEmpty(cacheContent))
            {
                return cacheContent;
            }
            var sysconf = _sysconfigrepository.GetSingle(p => p.Code == code);
            if (sysconf == null)
            {
                throw new Exception("数据表没有配置" + code);
            }
            var content = sysconf.SContent;
            string sysname = sysconf.Default1;//所属系统mes/erp
            RedisHelper.Set("sys_config" + code, content + "|" + sysname);
            return content;
        }

        /// <summary>
        /// 获取配置信息
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public fjSysConfig GetSysConfigByCode(string code)
        {
            //Repository<dynamic> _billdtrepository = new Repository<dynamic>();
            return _sysconfigrepository.GetSingle(p => p.Code == code);
        }


        /// <summary>
        /// 获取物料信息
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public fjBaseMater GetBaseMaterByExpression(Expression<Func<fjBaseMater, bool>> WhereExpression)
        {
            return _materrepository.GetSingle(WhereExpression);
        }
        /// <summary>
        /// 获取配置信息
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public fjSysConfig GetSysConfigByExpression(Expression<Func<fjSysConfig, bool>> WhereExpression)
        {
            return _sysconfigrepository.GetSingle(WhereExpression);
        }
        /// <summary>
        /// 获取单据信息
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public fjBillDocument GetBillDocumentByExpression(Expression<Func<fjBillDocument, bool>> WhereExpression)
        {
            return _docrepository.GetSingle(WhereExpression);
        }
        /// <summary>
        /// 获取反馈信息
        /// </summary>
        /// <param name="code"></param>
        /// <returns></returns>
        public List<fjBillFeedbackPush> GetBillFeedbackList(Expression<Func<fjBillFeedbackPush, bool>> WhereExpression)
        {
            return _billFbackPushrepository.GetList(WhereExpression);
        }
        ///// <summary>
        ///// 获取单据信息
        ///// </summary>
        ///// <param name="code"></param>
        ///// <returns></returns>
        //public fjBillDocument GetBillDocumentList(Expression<Func<fjBillDocument, bool>> WhereExpression)
        //{
        //    return _billdtrepository.Context.Queryable<fjBillDocument, fjSysConfig>((doc, conf) => new object[] {
        //      JoinType.Left, doc.BState == conf.Code
        //    }).Where((doc, conf) => doc.Status == 0)
        //    .Select((bc, bm) => bc).First();
        //}
        /// <summary>
        /// 更新SysConfig表字段
        /// </summary>
        /// <param name="updateModel"></param>
        /// <returns></returns>
        public bool UpdateSysConfigModelColumns(UpdateModelColumns<fjSysConfig> updateModel)
        {
            return _sysconfigrepository.Update(updateModel.Columns, updateModel.WhereExpression);
        }
        /// <summary>
        /// 更新hjBillFeedbackPush表字段
        /// </summary>
        /// <param name="updateModel"></param>
        /// <returns></returns>
        public bool UpdateBillFeedbackPushModelColumns(UpdateModelColumns<fjBillFeedbackPush> updateModel)
        {
            return _billFbackPushrepository.Update(updateModel.Columns, updateModel.WhereExpression);
        }
        public SRes<bool> DeleteDoc(Expression<Func<fjBillDocument, bool>> whereExpression)
        {
            var res = new SRes<bool>();
            res.ResData = _docrepository.Delete(whereExpression);
            return res;
        }
        public bool SyncMaterInfo(List<FJSyncMaterInfoResponseItem> ResData)
        {
            foreach (var item in ResData)
            {
                if (_materrepository.IsAny(p => p.Code == item.MatCode))
                {
                    _materrepository.UpdateModelColumns(p => new fjBaseMater() { IsHold = item.IsHold, HoldDuration = item.HoldDuration },
                       p => p.Code == item.MatCode);
                }
                else
                {
                    var model = _mapper.Map<fjBaseMater>(item);
                    _materrepository.Insert(model);
                }
            }
            return true;
        }
        public bool SyncMachineInfo(List<SyncMachineInfoResponseItem> ResData)
        {
            foreach (var item in ResData)
            {
                if (_basemachinforepository.IsAny(p => p.MachNo == item.MacCode))
                {
                    _basemachinforepository.UpdateModelColumns(p => new BillMachinfo() {  GrpCode = item.MacGroup, Direction = item.Direction,Station = item.LocCode,EditTime = DateTime.Now },
                       p => p.MachNo == item.MacCode);
                }
                else
                {
                    var model = _mapper.Map<BillMachinfo>(item);
                    _basemachinforepository.Insert(model);
                }
            }
            return true;
        }
        /// <summary>
        /// 帘线工单信息传输
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes CurtainProductionOrder(CurtainProductionOrderRequest reqDto)
        {
            var res = new SRes();
            var doc = _billdocrepository.GetSingle(p => p.DocsNo == reqDto.BillCode);
            if (doc == null)
            {
                doc = new BillDocsinfo();
                doc.WarehouseId = 0;
                doc.ReqNo = reqDto.BillCode;
                doc.DocsNo = reqDto.BillCode;
                doc.TypeNum = DocType.DocType_FJ_CurtainProduction.GetHashCode();
                doc.StateNum = DocState.DocState_Create.GetHashCode();
                doc.JsonContent = JsonConvert.SerializeObject(reqDto);
                doc.DownQty = 1;
                doc.IsStop = 0;
                var docinsert = _billdocrepository.Insert(doc);
                if (!docinsert)
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.ErrParam.GetDescription();
                    return res;
                }
            }
            _basemachinforepository.UpdateModelColumns(p => new BillMachinfo() { BillCode = reqDto.BillCode, WorkOrder = reqDto.WorkOrder, PlanQty = reqDto.PlanQty, EditTime = DateTime.Now }, p => reqDto.WbList.Contains(p.MachNo));
            return res;
        }
        /// <summary>
        /// 工单启动验证
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes CurtainOrderStartCheck(CurtainOrderStartCheckRequest reqDto)
        {
            var res = new SRes();
            var wetStack = _billBominfoRepository.GetSingle(p => p.BillCode == reqDto.BillCode);
            if (wetStack == null)
            {
                res.ResCode = 0;
                res.ResMsg = reqDto.BillCode + "没有配置垛型信息,请先配置垛型";
                return res;
            }
            return res;
        }
        
        /// <summary>
        /// 湿拉工字轮/芯股信息传输接口
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes SpoolMaterialInfoTrans(SpoolMaterialInfoTransRequest reqDto)
        {
            var res = new SRes();
            var container = _baseContinfo.GetSingle(p => p.ContBarCode == reqDto.SpoolCode);
            if (container == null)
            {
                var insertcon = new BaseContinfo()
                {
                    ContBarCode = reqDto.SpoolCode,
                    Name = reqDto.SpoolCode,
                    TypeCode = ContainerType.ContainerType_Spool.ToString(),
                    PrintQty = 1,
                    IsStop = 0,
                    WarehouseId = 0,
                    WeightQty = 0,
                    AddWho = "wms",
                    AddTime = DateTime.Now
                };
                //新加载具信息
                if (!_baseContinfo.Insert(insertcon))
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = "工字轮载具初始化失败";
                    return res;
                }
            }
            var mater = _basematerrepository.GetSingle(p => p.Code == reqDto.MatCode);
            if (mater == null)
            {
                res.ResCode = ResponseStatusCodeEnum.MaterInfoNotExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.MaterInfoNotExist.GetDescription();
                return res;
            }
            BillSpoolTrans billSpoolTrans = new BillSpoolTrans();
            billSpoolTrans.ConBarCode = reqDto.SpoolCode;
            billSpoolTrans.BillCode = reqDto.BillCode;
            billSpoolTrans.WorkOrder = reqDto.WorkOrder;
            billSpoolTrans.AddTime = DateTime.Now;
            var stock = _billInvnowrepository.GetSingle(p => p.ContGrpBarCode == reqDto.SpoolCode);
            if (stock != null && stock.InvStateCode == InvState.InvEcecState_In.ToString())
            {
                billSpoolTrans.ErrType = 1;
                billSpoolTrans.Memo = "该工字轮条码号已在库中，请检查RFID号是否重复";
            }
            if (stock != null && stock.InvStateCode == InvState.InvEcecState_OutGoing.ToString())
            {
                billSpoolTrans.ErrType = 1;
                billSpoolTrans.Memo = "该工字轮条码号存在出库中任务，请检查上一个任务是否已经完成";
            }

            //条码验证
            var barstock = _billInvnowrepository.GetSingle(p => p.InvBarCode == reqDto.MatBarCode);
            if (barstock != null && barstock.InvStateCode == InvState.InvEcecState_In.ToString())
            {
                billSpoolTrans.ErrType = 1;
                billSpoolTrans.Memo = "该材料号已在库中，请检查是否重复";
            }
            if (barstock != null && barstock.ContGrpBarCode != reqDto.SpoolCode)
            {
                billSpoolTrans.ErrType = 1;
                billSpoolTrans.Memo = reqDto.MatBarCode + "该材料号已经绑定" + barstock.ContGrpBarCode + "，请检查是否重复";
            }
            var barinfo = _billInvinitrepository.GetSingle(p => p.InvBarCode == reqDto.MatBarCode);
            if (barinfo == null)
            {
                barinfo = new BillInvinit()
                {
                    InvBarCode = reqDto.MatBarCode,
                    WarehouseId = 0,
                    ContGrpId = IdFactory.NewId(),
                    ContGrpBarCode = reqDto.SpoolCode,
                    ExecStateCode = InvLockState.InvState_Normal.ToString(),
                    ExecDocsNo = reqDto.WorkOrder,
                    ExecDocsRowNo = reqDto.MatBarCode,
                    ExecDocsTypeCode = DocType.DocType_HJ_CopperProductStockIn.GetHashCode().ToString(),
                    InvInOut = InvInOutType.In.GetHashCode(),
                    ExecWho = "MES",
                    EditTime = DateTime.Now,
                    InvStateCode = InvState.InvEcecState_BuildUp.ToString(),
                    InDocsNo = reqDto.BillCode,
                    InDocsRowNo = reqDto.MatBarCode,
                    SuppCode = "",
                    MatId = mater.Id,
                    MatCode = mater.Code,
                    MatName = mater.Name,
                    LengthQty = reqDto.Length,
                    TareWQty = reqDto.Weight,
                    ProductTime = reqDto.ProductDate,
                    RFIDBarCode = "",
                    ProductLineNo = "",
                    Grade = reqDto.Grade,
                    HWBarCode = "",
                    HWTypeCode = reqDto.SpoolType,//工字轮类型
                    IsFast = reqDto.IsFast,
                    IsRework = false,
                    CLBarCode = reqDto.MatBarCode,
                    Size = 1,
                    AddTime = DateTime.Now,
                    BackReason = "",
                    IsBack = reqDto.IsBack,
                    SilkTypeCode = reqDto.SilkType,
                    IsCore = reqDto.BusType == "2",
                    
                };
                 _billInvinitrepository.InsertReturnEntity(barinfo);
                 _billSpoolTransrepository.InsertReturnEntity(billSpoolTrans);
            }
            return res;
        }

        /// <summary>
        /// 分配分拣库
        /// </summary>
        /// <returns></returns>
        public bool AllocationWarehouseSort(AllocationWarehouseSortRequest reqDto)
        {
            var list = _billSpoolTransrepository.AsQueryable().Where(p => p.WarehouseSort == 0).Take(reqDto.TaskCount).ToList();
            foreach (var item in list)
            {
                var maclist = _basemachinforepository.AsQueryable().Where(p => p.WorkOrder == item.WorkOrder);
                var warelist = maclist.Select(p => p.WarehouseCode).Distinct();
                if (!warelist.Any())
                {
                    _billSpoolTransrepository.UpdateModelColumns(p => new BillSpoolTrans()
                    {
                        ErrType = 1,
                        ErrMsg = "没有配置机台信息",
                        EditTime = DateTime.Now
                    }, p => p.ConBarCode == item.ConBarCode);
                }
                else if (warelist.Count() == 1)
                {
                    int sort = int.Parse(warelist.First().Substring(0, 1));
                    _billSpoolTransrepository.UpdateModelColumns(p => new BillSpoolTrans()
                    {
                        WarehouseSort = sort,
                        Direct = warelist.First().Substring(1, 1),
                        EditTime = DateTime.Now
                    }, p => p.ConBarCode == item.ConBarCode);
                }
                else
                {
                    var waretemplist = maclist.Select(p => new { p.WarehouseCode,p.WorkOrder,p.BillCode, p.PlanQty }).Distinct();
                    var warehouselist = _basewarehouserepository.GetList().Select(p => p.Code);
                    foreach (var warehouse in warehouselist)
                    {
                        var stackdetaillist = _billBomsetinfoRepository.AsQueryable().Where(p => p.WarehouseCode == warehouse);
                        getMatProport(item.MatCode, warehouse);
                    }
                    //根据垛型及库存比例分配
                    //找出该物料类型在每个库所要求的所有量
                   

                    //找出该物料库存在当前库所有
                }
            }
            return true;
        }
        /// <summary>
        /// 二次扫码分配输送地址
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes AllocationConveyorSort(AllocationConveyorSortRequest reqDto)
        {
            var res = new SRes();
            var baritem = _billSpoolTransrepository.GetFirst(p => p.ConBarCode == reqDto.BarCode);
            //判断当前库是否有mix垛型
            var mixrow = _billBomsetinfoRepository.AsQueryable().Where(p => p.IsMixRow == 1 && p.WarehouseCode == baritem.WarehouseCode);
            if (mixrow == null || !mixrow.Any())
            {
                var matcodelist = _billBomsetinfoRepository.AsQueryable().Where(p => p.WarehouseCode == baritem.WarehouseCode);
                var curmatrate = matcodelist.Where(p => p.MatCode == baritem.MatCode).Count() / matcodelist.Count();
                //需要的总量

            }
            else
            {

            }
            var translist = _billSpoolTransrepository.AsQueryable().Where(p => p.WarehouseCode == baritem.WarehouseCode).ToList();
            foreach (var item in translist.GroupBy(p=>p.ConveyorSort))
            {

            }
            return res;
        }

        public decimal getMatProport(string matcode, string warehousecode)
        {
            //计算此仓库所有该物料的量
            //每的单子（每盘的数量）*预计盘数
            var stackdetaillist = _billBomsetinfoRepository.AsQueryable().Where(p => p.WarehouseCode == warehousecode);
            return 0;
        }

        /// <summary>
        /// 帘线领料出库
        /// </summary>
        /// <param name="reqDto"></param>
        /// <returns></returns>
        public SRes CurtainProductionStockOut(CurtainProductionStockOutRequest reqDto)
        {
            var res = new SRes();
            
            var warehosue = _baseWareHouserepository.GetSingle(p => p.Code == reqDto.WareCode);
            if (warehosue == null)
            {
                res.ResCode = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetHashCode();
                res.ResMsg = ResponseStatusCodeEnum.WarehouseCodeNotExist.GetDescription();
                return res;
            }
            var doc = _docrepository.GetSingle(p => p.DocNo == reqDto.BillCode);
            if (doc == null)
            {
                doc = new fjBillDocument();
                doc.WarehouseId = warehosue.Id;
                //保存单据信息
                doc.ReqNo = reqDto.ReqId;
                doc.DocNo = reqDto.BillCode;
                doc.TypeCode = DocType.DocType_FJ_CurtainProductionStockOut.ToString();
                doc.StateCode = DocState.DocState_Create.ToString();
                doc.ContentJson = JsonConvert.SerializeObject(reqDto);
                doc.DownQty = 1;
                var docinsert = _docrepository.Insert(doc);
                if (!docinsert)
                {
                    res.ResCode = ResponseStatusCodeEnum.ErrParam.GetHashCode();
                    res.ResMsg = ResponseStatusCodeEnum.ErrParam.GetDescription();
                    return res;
                }
            }
            return res;
        }
        public SRes ProductionBack(FjProductionBackRequest reqDto)
        {
            var res = new SRes();
            return res;
        }
        public SRes ProductionLeftFeedBack(string doccode)
        {
            var res = new SRes();
            return res;
        }
        public SRes ErrorMaterialStockOut(FjErrorMaterialStockOutRequest reqDto)
        {
            var res = new SRes();
            return res;
        }
        public SRes BGradeMaterialStockOut(BGradeMaterialStockOutRequest reqDto)
        {
            var res = new SRes();
            return res;
        }
        public SRes StockChange(FjStockChangeRequest reqDto)
        {
            var res = new SRes();
            return res;
        }
        public SRes ManualBuildStockTrans(ManualBuildStockTransRequest reqDto)
        {
            var res = new SRes();
            return res;
        }
        public SRes BomInfoTrans(BomInfoTransRequest reqDto)
        {
            var res = new SRes();
            return res;
        }
    }
}