using iWareCC.WCF;
using iWareCommon.Utils;
using iWareModel;
using iWareModel.Entity;
using iWareSql.DataAccess;
using iWareSql.DBModel;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using XiGang.Core.Model;
using XiGang.Core.Model.PostParamModels;
using XiGang.Core.Model.PostParamModels.Task;
using static System.Windows.Forms.AxHost;

namespace iWareCC.BLL
{
    /// <summary>
    /// 【组盘】的业务处理类
    /// </summary>
    public class SalverMaterialBindBLL
    {
        /// <summary>
        /// 组盘
        /// </summary>
        /// <param name="_unitOfWork"></param>
        /// <param name="request"></param>
        /// <param name="user"></param>
        /// <param name="material"></param>
        /// <param name="salver"></param>
        /// <returns></returns>
        public static MessageModel<string> SalverMaterialBind(
            bool isValidate1015ScanValue,
            bool isBtj,
            C_Task_InStoreSlaverParam Task_InStoreSlaver, C_AnalyzeMaterialPostParam request,
            string userName, int userId, string inStoreNo
           )
        {
            MessageModel<string> result = new MessageModel<string>();
            var errMsg = "";
            try
            {
                using (DbModel context = new DbModel())
                {

                    #region 生成最新的序列号 【Eidtby shaocx,2023-02-21】
                    string taskSequenceGuid = "";
                    int taskSequence = 0;
                    if (isValidate1015ScanValue)
                    {
                        TaskSequenceEntity taskSequenceEntity = MyGenerateTaskSequence(context);
                        taskSequence = taskSequenceEntity.TaskSequence;
                        taskSequenceGuid = taskSequenceEntity.TaskSequenceGuid;
                    }
                    else
                    {
                        taskSequenceGuid = Guid.NewGuid().ToString();
                    }
                    #endregion

                    //验证1015站点是否有库存存在！
                    //var existStores = context.V_AllStore.Where(x => x.RgvStationCode == "1015").ToList();
                    var existStores = context.V_AllStore.Where(x => x.RgvStationCode == inStoreNo).ToList();
                    if (existStores != null && existStores.Count > 0)
                    {
                        result = MessageModel<string>.Fail($"入库口{inStoreNo}已经有库存存在！托盘号:" + existStores[0].SalverCode + ",序列号:" + existStores[0].SerialNumber);
                        return result;
                    }


                    //_unitOfWork.BeginTran();

                    //1、寻找空库位

                    Task_Main mainTask = new Task_Main();
                    mainTask.IsVirtual = false;//非虚拟入库
                    mainTask.IsBtj = isBtj;
                    if (isBtj)
                    {
                        mainTask.IsBtjReceive = true;
                        mainTask.BtjReceiveTime = DateTime.Now;
                    }

                    //mainTask.TaskSequence = await GenerateTaskSequence();//生成最新的任务序列号
                    mainTask.TaskSequence = taskSequence;//生成最新的任务序列号
                    mainTask.TaskSequenceGuid = taskSequenceGuid;

                    if (request == null)
                    {
                        mainTask.TaskNo = Task_InStoreSlaver.TaskNo;
                    }
                    else
                    {
                        //阻止出现两次重复扫码组盘的情况
                        //List<V_TaskMain> NewV_TaskMain = await _V_TaskMain.Query(a => a.SerialNumber == request.SerialNumber);
                        List<V_TaskMain> NewV_TaskMain = context.V_TaskMain.Where(a => a.SerialNumber == request.SerialNumber).ToList();
                        foreach (var item in NewV_TaskMain)
                        {
                            if (item.TaskState != (int)MainTaskStatusEnum.已完成 && item.TaskState != (int)MainTaskStatusEnum.已取消)
                            {
                                result = MessageModel<string>.Fail("入库任务已存在该序列号的任务");
                                return result;
                            }
                            else
                            {
                                //List<V_Store> storeList = await v_StoreServices.Query(a => a.SerialNumber == request.SerialNumber);
                                List<V_Store> storeList = context.V_Store.Where(a => a.SerialNumber == request.SerialNumber).ToList();
                                if (storeList != null && storeList.Count > 0)
                                {
                                    result = MessageModel<string>.Fail($"序列号{request.SerialNumber}已经在立体库中，库位号{storeList[0].SrmStationCode}");
                                    return result;
                                }
                            }
                        }
                        mainTask.TaskNo = TaskNoHelper.GenerateTaskNo("IN");
                    }
                    mainTask.TaskName = "入库";

                    mainTask.InOutFlag = (int)MainInOutFlagEnum.入库;
                    mainTask.InOutFlagName = MainInOutFlagEnum.入库.ToString();

                    //先模拟写死
                    //暂时读取本项目的，以后要改为调用服务的 ！！！！
                    //起点,写死
                    //var sourcePlaceList = await base_StationServices.Query(x => x.RgvStationCode == ((int)RgvLocation.入库口1015).ToString());
                    var sourcePlaceList = context.Base_Station.Where(x => x.RgvStationCode == inStoreNo).ToList();
                    if (sourcePlaceList == null || sourcePlaceList.Count == 0)
                    {
                        result = MessageModel<string>.Fail($"没有找到RGV站点{inStoreNo}的站点基础数据");
                        return result;
                    }
                    var sourcePlace = sourcePlaceList[0];

                    //判断起点是否有任务被占用
                    //var validateStationIsAllowUseResult = await base_StationServices.ValidateStationIsAllowUse(sourcePlace.Id, task_PartServices);
                    var validateStationIsAllowUseResult = StationHandler.ValidateStationIsAllowUse(sourcePlace.Id, context);
                    if (validateStationIsAllowUseResult.data == false)
                    {
                        result = MessageModel<string>.Fail(validateStationIsAllowUseResult.msg);
                        return result;
                    }
                    mainTask.SourcePlace = sourcePlace.Id;
                    mainTask.RealSourcePlace = sourcePlace.RgvStationCode;


                    Base_Material newMaterial = null;
                    Base_Salver salver = null;
                    if (request == null)
                    {
                        //增加空托
                        //newMaterial = await base_MaterialServices.CreateEmptySlaverMaterial(Task_InStoreSlaver.Qty, "入库时，新建空托", user);
                        //salver = await base_SalverServices.CreateVirtualSalver("入库时，新建空托", user);
                        newMaterial = MaterialHandler.CreateEmptySlaverMaterial(context, "入库时，新建空托", Task_InStoreSlaver.Qty);
                        salver = SalverHandler.CreateVirtualSalver(context, "入库时，新建空托");
                    }
                    else
                    {
                        //增加物料
                        //首先去判断该物料是否存在
                        //var existMaterialResult = await base_MaterialServices.GetMaterialBySerialNumber(request.SerialNumber, false);
                        var existMaterialResult = MaterialHandler.GetMaterialBySerialNumber(context, request.SerialNumber, false);
                        if (existMaterialResult.success == false)
                        {
                            result = MessageModel<string>.Fail(existMaterialResult.msg);
                            return result;
                        }
                        else
                        {
                            newMaterial = existMaterialResult.data;
                        }
                        if (newMaterial == null)
                        {
                            //newMaterial = await base_MaterialServices.CreateCargoMaterial("入库时，新建物料", request, user);
                            newMaterial = MaterialHandler.CreateCargoMaterial(context, request, "入库时，新建物料", request.SerialNumber, request.OrderNo);

                            //如果是新物料，并且是没有主机厂、机型、系列字段，则需要重新使用服务获取下
                            if (string.IsNullOrEmpty(request.Supplier) || request.items_ModelNumber == null)
                            {
                                mainTask.IsUpdateMatFinish = false;
                                mainTask.UpdateMatFinishTime = DateTime.Now;
                                mainTask.UpdateMatFinishNum = 0;
                            }
                            else
                            {
                                mainTask.IsUpdateMatFinish = true;
                                mainTask.UpdateMatFinishTime = DateTime.Now;
                                mainTask.UpdateMatFinishNum = 0;
                            }
                        }

                        //判断托盘是否存在，如果存在，就不需要重建，如果不存在，就新建托盘
                        //var salverResult = await base_SalverServices.GetSalveByCodeForInTask(request.SalverCode, user, base_Salver_V_StationServices, base_Salver_V_MaterialServices);
                        var salverResult = SalverHandler.GetSalveByCodeForInTask(context, request.SalverCode, out errMsg);
                        if (!string.IsNullOrEmpty(errMsg))
                        {
                            result = MessageModel<string>.Fail(errMsg);
                            return result;
                        }
                        salver = salverResult;
                    }


                    mainTask.MaterialId = newMaterial.Id;
                    mainTask.SerialNumber = newMaterial.SerialNumber;
                    mainTask.OrderNo = newMaterial.OrderNo;
                    mainTask.SalverId = salver.Id;
                    mainTask.SalverCode = salver.SalverCode;

                    //物料信息
                    //XiGangCommonHelper.SetMaterialForMainTask(ref mainTask, newMaterial);
                    MainTaskHandler.SetMaterialForMainTask(ref mainTask, newMaterial);


                    ////绑定托盘和物料的关系
                    //await base_Salver_V_MaterialServices.CreateCvIRelation(userName, salver, newMaterial, "入库时，新建绑定托盘和物料的关系");
                    ////绑定托盘和站点的关系
                    //await base_Salver_V_StationServices.CreateCvPRelation(userName, salver, sourcePlace, Salver_V_Station_StateEnum.入库绑定, "入库时，新建绑定托盘和站点的关系");
                    //绑定托盘和物料的关系
                    Salver_Material_Handler.CreateCvIRelation(context, userName, salver, newMaterial, "入库时，新建绑定托盘和物料的关系");
                    //绑定托盘和站点的关系
                    Salver_Station_Handler.CreateCvPRelation(context, userName, salver, sourcePlace, Salver_V_Station_StateEnum.入库绑定, "入库时，新建绑定托盘和站点的关系");

                    ////

                    var _taskType = MainTaskTypeEnum.自动入库;
                    mainTask.TaskType = Convert.ToInt32(_taskType);
                    mainTask.TaskTypeName = _taskType.ToString();
                    var _taskState = MainTaskStatusEnum.已组盘;
                    mainTask.TaskState = Convert.ToInt32(_taskState);
                    mainTask.TaskStateName = _taskState.ToString();


                    mainTask.CreateTime = mainTask.ModifyTime = mainTask.StartTime = DateTime.Now;
                    mainTask.CreateBy = mainTask.ModifyBy = userName;
                    mainTask.CreateId = mainTask.ModifyId = userId;
                    mainTask.OperationRemark = "添加";

                    //int mainTaskId = await _dal.Add(mainTask);
                    context.Task_Main.Add(mainTask);
                    //if (mainTaskId <= 0)
                    //{
                    //    result = MessageModel<string>.Fail("新增主任务失败");
                    //    return result;
                    //}

                    //锁定站点

                    sourcePlace.IsLock = true;
                    sourcePlace.IsHasTaskDoing = true;
                    sourcePlace.OperationRemark = "创建入库任务，锁定库位";
                    //await base_StationServices.Update(sourcePlace);

                    context.SaveChanges();


                    result = MessageModel<string>.Success("成功");
                    return result;

                }
            }
            catch (System.Exception ex)
            {
                throw ex;
            }
            finally
            {
                //if (result.success)
                //{
                //    _unitOfWork.CommitTran();
                //}
                //else
                //{
                //    _unitOfWork.RollbackTran();
                //}
            }
        }


        /// <summary>
        /// 生成最新的任务序列号
        /// </summary>
        private static TaskSequenceEntity MyGenerateTaskSequence(DbModel edm)
        {
            TaskSequenceEntity entity = new TaskSequenceEntity();
            entity = MainTaskHandler.GetTaskSequenceEntity(edm);
            if (entity == null)
            {
                throw new Exception("生成最新的任务序列号失败");
            }
            if (entity.TaskSequence == 0)
            {
                throw new Exception("生成最新的任务序列号为0");
            }
            return entity;
        }
    }
}