using Newtonsoft.Json;
using SharpCompress.Compressors.Xz;
using System.Reflection.Emit;
using WIDESEA_Common;
using WIDESEA_Common.LevelChange;
using WIDESEA_Core;
using WIDESEA_Core.Const;
using WIDESEA_Core.Enums;
using WIDESEA_Core.Helper;
using WIDESEA_DTO.WMS;
using WIDESEA_Model.Models;
using WIDESEA_Model.Models.GZ_ZC.DistributeWheels;
using WIDESEA_StorageBasicRepository;
using WIDESEA_StorageBasicService;

namespace WIDESEA_StoragIntegrationServices
{
    public partial class ToAPPService
    {
        /// <summary>
        /// 保存车轴数据
        /// </summary>
        /// <param name="saveModel"></param>
        /// <returns></returns>
        public WebResponseContent SaveCZInfo(SaveModel saveModel)
        {
            WebResponseContent content = new WebResponseContent();
            try
            {
                //如当前存在未开始入库的车轮或制动盘数据,则禁止保存新数据 以防数据混乱
                var waitInbound = _CZInfo_MesRepository.QueryFirst(x => x.CurrentStatue == "0");
                if (waitInbound != null) throw new Exception("当前存在未开始入库的车轴数据,请先上架启动后再保存信息!");

                //车轴条码
                string czCode = saveModel.MainData["cztm"].ToString();
                if (string.IsNullOrEmpty(czCode))
                    throw new Exception($"车轴条码不能为空");

                //车轴号
                string czh = saveModel.MainData["czh"].ToString();
                if (string.IsNullOrEmpty(czh))
                    throw new Exception($"车轴号不能为空");
                //var clinfo = _InWheels_MesRepository.QueryFirst(x => x.Wheels_code == czCode);
                //if (clinfo != null) throw new Exception("车轮录入信息已存在");

                //序列号
                //string madeUnit = saveModel.MainData["xlh"].ToString();
                //轮对条码  
                string ldtm = saveModel.MainData["ldtm"].ToString();
                //车型
                string Cartype = saveModel.MainData["chexing"].ToString();
                if (string.IsNullOrEmpty(Cartype)) throw new Exception("选配失败：车轴车型参数为空");

                //车轴型号
                string czxh = saveModel.MainData["czxh"].ToString();

                //车轮型号
                string clxh = saveModel.MainData["clxh"].ToString();

                //动拖属性
                string mttype = saveModel.MainData["mttype"].ToString();

                //左轮座直径A1
                string zlzA1 = saveModel.MainData["zlzA1"].ToString();
                //左轮座直径A1
                string zlzA2 = saveModel.MainData["zlzA2"].ToString();
                //左轮座直径A1
                string zlzA3 = saveModel.MainData["zlzA3"].ToString();
                //左轮座直径A
                string zlzA = saveModel.MainData["zlza"].ToString();

                //左轮座直径B1
                string zlzB1 = saveModel.MainData["zlzB1"].ToString();
                //左轮座直径B1
                string zlzB2 = saveModel.MainData["zlzB2"].ToString();
                //左轮座直径B1
                string zlzB3 = saveModel.MainData["zlzB3"].ToString();
                //左轮座直径B
                string zlzB = saveModel.MainData["zlzb"].ToString();

                //左轮座直径C1
                string zlzC1 = saveModel.MainData["zlzC1"].ToString();
                //左轮座直径C1
                string zlzC2 = saveModel.MainData["zlzC2"].ToString();
                //左轮座直径C1
                string zlzC3 = saveModel.MainData["zlzC3"].ToString();
                //左轮座直径C
                string zlzC = saveModel.MainData["zlzc"].ToString();

                //右轮座直径A1
                string ylzA1 = saveModel.MainData["ylzA1"].ToString();
                //右轮座直径A1
                string ylzA2 = saveModel.MainData["ylzA2"].ToString();
                //右轮座直径A1
                string ylzA3 = saveModel.MainData["ylzA3"].ToString();
                //右轮座直径A
                string ylzA = saveModel.MainData["ylza"].ToString();

                //右轮座直径B1
                string ylzB1 = saveModel.MainData["ylzB1"].ToString();
                //右轮座直径B1
                string ylzB2 = saveModel.MainData["ylzB2"].ToString();
                //右轮座直径B1
                string ylzB3 = saveModel.MainData["ylzB3"].ToString();
                //右轮座直径B
                string ylzB = saveModel.MainData["ylzb"].ToString();

                //右轮座直径C1
                string ylzC1 = saveModel.MainData["ylzC1"].ToString();
                //右轮座直径C1
                string ylzC2 = saveModel.MainData["ylzC2"].ToString();
                //右轮座直径C1
                string ylzC3 = saveModel.MainData["ylzC3"].ToString();
                //右轮座直径C
                string ylzC = saveModel.MainData["ylzc"].ToString();

                //左轮座直径
                string zlzzj = saveModel.MainData["zlzzj"].ToString();
                //右轮座直径
                string ylzzj = saveModel.MainData["ylzzj"].ToString();

                //新旧
                string newOrOld = saveModel.MainData["NOdirection"].ToString();
                if (string.IsNullOrEmpty(newOrOld)) throw new Exception("未选择新旧类型,请选择!");

                //车轮位置
                string wheelsPosition = saveModel.MainData["wheelsPosition"].ToString();
                if (string.IsNullOrEmpty(wheelsPosition)) throw new Exception("未选择车轮位置,请选择!");

                //左轮等级
                string leftLevel = saveModel.MainData["zlzdj"].ToString();
                if (string.IsNullOrEmpty(leftLevel)) throw new Exception("选配失败：车轴左轮座等级参数为空");
                //右轮等级
                string rightLevel = saveModel.MainData["ylzdj"].ToString();
                if (string.IsNullOrEmpty(rightLevel)) throw new Exception("选配失败：车轴右轮座等级参数为空");

                //维修任务
                string wxrw = saveModel.MainData["wxrw"].ToString();
                if (string.IsNullOrEmpty(wxrw)) throw new Exception("选配失败：维修任务参数为空");

                string level = string.Empty;
                //string rightlevel = string.Empty;
                if ("all".Equals(wheelsPosition))
                {
                    level = LevelChangeHelper.LevelChangeType(leftLevel);
                    if (string.IsNullOrEmpty(level)) throw new Exception("等级转换失败,请检查接口等级参数");
                }
                else if ("left".Equals(wheelsPosition))
                {
                    level = LevelChangeHelper.LevelChangeType(leftLevel);
                    if (string.IsNullOrEmpty(level)) throw new Exception("等级转换失败,请检查接口等级参数");
                    //level = leftLevel;
                }
                else if ("right".Equals(wheelsPosition))
                {
                    level = LevelChangeHelper.LevelChangeType(rightLevel);
                    if (string.IsNullOrEmpty(level)) throw new Exception("等级转换失败,请检查接口等级参数");
                    //level = rightLevel;
                }

                string rw = CheckTaskChangeHelper.CheckTaskChange(wxrw);
                if (string.IsNullOrEmpty(rw)) throw new Exception("维修任务转换失败,请检查维修任务参数");

                if (rw != newOrOld) throw new Exception("选配失败:选配新旧轮与维修任务解析不一致");

                Dt_SelectionStandards selectionStandards = _SelectionStandardsRepository.QueryFirst(x => x.CarType.Contains(Cartype) && x.mttype == mttype && x.neworold == newOrOld && level.Contains(x.gkdj));
                if (selectionStandards == null) throw new Exception($"此车型{Cartype}的选配标准异常,请核对选配标准信息!");

                Dt_CZInfo_mes CZInfo_Mes = new Dt_CZInfo_mes
                {
                    CZTM = czCode,
                    CHEXING = Cartype,
                    CreateDate = DateTime.Now,
                    Creater = "admin",
                    CurrentStatue = "1",
                    CZH = czh,
                    CZXH = czxh,
                    LDTM = ldtm,
                    MTTYPE = mttype,
                    ZLZA1 = zlzA1,
                    ZLZA2 = zlzA2,
                    ZLZA3 = zlzA3,
                    ZLZA = zlzA,
                    ZLZB1 = zlzB1,
                    ZLZB2 = zlzB2,
                    ZLZB3 = zlzB3,
                    ZLZB = zlzB,
                    ZLZC1 = zlzC1,
                    ZLZC2 = zlzC2,
                    ZLZC3 = zlzC3,
                    ZLZC = zlzC,
                    YLZA1 = ylzA1,
                    YLZA2 = ylzA2,
                    YLZA3 = ylzA3,
                    YLZA = ylzA,
                    YLZB1 = ylzB1,
                    YLZB2 = ylzB2,
                    YLZB3 = ylzB3,
                    YLZB = ylzB,
                    YLZC1 = ylzC1,
                    YLZC2 = ylzC2,
                    YLZC3 = ylzC3,
                    YLZC = ylzC,
                    ZLZZJ = zlzzj,
                    YLZZJ = ylzzj,
                    ZLZDJ = leftLevel,
                    YLZDJ = rightLevel,
                    WXRW = wxrw
                };

                //左出库车轮
                Dt_WheelsStock leftContainer = null;
                //右出库车轮
                Dt_WheelsStock rightContainer = null;

                //同温时间
                var hourpara = _configService.GetByConfigKey(CateGoryConst.CONFIG_SYS_Parameters, SysConfigConst.TempHour);
                int hour = hourpara.ConfigValue.ObjToInt();

                //找出所有符合条件的库存车轮
                var WheelsList = _WheelsStockRepository.QueryData(x => x.Wheels_CurrentStatue == 1 && x.Wheels_mttype == CZInfo_Mes.MTTYPE && x.Wheels_ldxh == clxh && x.Wheels_NewOrOld == newOrOld && x.CreateDate.AddHours(hour) <= DateTime.Now);
                //x.Wheels_CarType  == CZInfo_Mes.CHEXING && x.Wheels_ldtm == CZInfo_Mes.LDTM && selectionStandards.CarType.Contains(x.Wheels_CarType)
                if (null != WheelsList && WheelsList.Count > 0)
                {
                    if ("all".Equals(wheelsPosition) || string.IsNullOrEmpty(wheelsPosition))
                    {
                        if (null == leftContainer)
                        {
                            leftContainer = _WheelsStockService.GetSelectionWheelsStock(WheelsList, selectionStandards, CZInfo_Mes, "left", newOrOld);
                            if (null != leftContainer)
                                WheelsList.Remove(leftContainer);
                        }
                        if (null == rightContainer)
                        {
                            rightContainer = _WheelsStockService.GetSelectionWheelsStock(WheelsList, selectionStandards, CZInfo_Mes, "right", newOrOld);
                            if (null != rightContainer)
                                WheelsList.Remove(rightContainer);
                        }
                        //if (null == leftContainer || null == rightContainer)
                    }
                    else if ("left".Equals(wheelsPosition))
                    {
                        leftContainer = _WheelsStockService.GetSelectionWheelsStock(WheelsList, selectionStandards, CZInfo_Mes, "left", newOrOld);
                        //if (null == leftContainer)
                    }
                    else if ("right".Equals(wheelsPosition))
                    {
                        rightContainer = _WheelsStockService.GetSelectionWheelsStock(WheelsList, selectionStandards, CZInfo_Mes, "right", newOrOld);
                        //if (null == rightContainer)
                    }
                }

                if ("all".Equals(wheelsPosition))
                {
                    if (null == leftContainer || null == rightContainer)
                        return content.Error("未找到两侧可匹配的出库车轮,车型：" + Cartype);


                }

                if (null != leftContainer || null != rightContainer)
                {
                    List<Dt_Task> listTask = new List<Dt_Task>();
                    List<DtLocationInfo> locationInfos = new List<DtLocationInfo>();
                    List<Dt_WheelsStock> wheelsStocks = new List<Dt_WheelsStock>();
                    List<WMSTaskDTO> listTaskDTO = new List<WMSTaskDTO>();
                    if (null != leftContainer)
                    {
                        Dt_Task leftTask = CreateOutTask(leftContainer, czCode);

                        leftContainer.Wheels_CurrentStatue = 2;

                        DtLocationInfo lefolocation = _locationRepository.QueryFirst(x => x.LocationCode == leftContainer.Wheels_Location);
                        lefolocation.LocationStatus = (int)LocationEnum.InStockDisable;

                        //int taskNum = _taskRepository.GetTaskNo().Result;
                        //Dt_Task leftTask = new Dt_Task
                        //{
                        //    CreateDate = DateTime.Now,
                        //    Creater = "admin",
                        //    CurrentAddress = leftContainer.Wheels_Location,
                        //    Dispatchertime = DateTime.Now,
                        //    Grade = 1,
                        //    IsCheck = true,
                        //    NextAddress = "2010",
                        //    PalletCode = leftContainer.Wheels_code,
                        //    Roadway = "SC1",
                        //    SourceAddress = leftContainer.Wheels_Location,
                        //    TargetAddress = "2021",
                        //    TaskNum = taskNum,
                        //    TaskState = (int)TaskOutStatusEnum.OutNew,
                        //    TaskType = (int)TaskOutboundTypeEnum.OutWheels
                        //};
                        WMSTaskDTO leftTaskDTO = new WMSTaskDTO
                        {
                            IsCheck = true,
                            Grade = 1,
                            RoadWay = "SC1",
                            PalletCode = leftContainer.Wheels_Num,
                            SourceAddress = leftContainer.Wheels_Location,
                            TargetAddress = "2021",
                            TaskNum = leftTask.TaskNum.Value,
                            TaskState = (int)TaskOutStatusEnum.OutNew,
                            TaskType = (int)TaskOutboundTypeEnum.OutWheels,
                            CarType = leftContainer.Wheels_CarType,
                            WheelsNewOrOld = leftContainer.Wheels_NewOrOld,
                            wheels_gkcc = leftContainer.Wheels_gkcc,
                            wheels_mttype = leftContainer.Wheels_mttype,
                            WheelsLX = leftContainer.Wheels_ldxh
                        };

                        listTask.Add(leftTask);
                        listTaskDTO.Add(leftTaskDTO);
                        wheelsStocks.Add(leftContainer);
                        locationInfos.Add(lefolocation);
                    }
                    if (null != rightContainer)
                    {
                        Dt_Task rightTask = CreateOutTask(rightContainer, czCode);

                        rightContainer.Wheels_CurrentStatue = 2;

                        DtLocationInfo rightlocation = _locationRepository.QueryFirst(x => x.LocationCode == rightContainer.Wheels_Location);
                        rightlocation.LocationStatus = (int)LocationEnum.InStockDisable;
                        //int rightTaskNum = _taskRepository.GetTaskNo().Result;
                        //Dt_Task rightTask = new Dt_Task
                        //{
                        //    CreateDate = DateTime.Now,
                        //    Creater = "admin",
                        //    CurrentAddress = rightContainer.Wheels_Location,
                        //    Dispatchertime = DateTime.Now,
                        //    Grade = 1,
                        //    IsCheck = true,
                        //    NextAddress = "2010",
                        //    PalletCode = rightContainer.Wheels_code,
                        //    Roadway = "SC1",
                        //    SourceAddress = rightContainer.Wheels_Location,
                        //    TargetAddress = "2021",
                        //    TaskNum = rightTaskNum,
                        //    TaskState = (int)TaskOutStatusEnum.OutNew,
                        //    TaskType = (int)TaskOutboundTypeEnum.OutWheels,
                        //};
                        WMSTaskDTO rihgtTaskDTO = new WMSTaskDTO
                        {
                            IsCheck = true,
                            Grade = 1,
                            RoadWay = "SC1",
                            PalletCode = rightContainer.Wheels_Num,
                            SourceAddress = rightContainer.Wheels_Location,
                            TargetAddress = "2021",
                            TaskNum = rightTask.TaskNum.Value,
                            TaskState = (int)TaskOutStatusEnum.OutNew,
                            TaskType = (int)TaskOutboundTypeEnum.OutWheels,
                            CarType = rightContainer.Wheels_CarType,
                            WheelsNewOrOld = rightContainer.Wheels_NewOrOld,
                            wheels_gkcc = rightContainer.Wheels_gkcc,
                            wheels_mttype = rightContainer.Wheels_mttype,
                            WheelsLX = rightContainer.Wheels_ldxh
                        };
                        listTask.Add(rightTask);
                        listTaskDTO.Add(rihgtTaskDTO);
                        wheelsStocks.Add(rightContainer);
                        locationInfos.Add(rightlocation);
                    }

                    _unitOfWorkManage.BeginTran(); //开启事务



                    _CZInfo_MesRepository.AddData(CZInfo_Mes);          //添加车轴信息
                    _WheelsStockRepository.UpdateData(wheelsStocks);    //更新库存数据
                    _locationRepository.UpdateData(locationInfos);      //更新库位数据  
                    _taskRepository.AddData(listTask);                  //添加任务数据
                    if(leftContainer != null)
                    {
                        _AxleshelfService.AddAxleshe(leftContainer, CZInfo_Mes,clxh, wheelsPosition, newOrOld);    //添加车轴上架记录
                    }
                    if (rightContainer != null)
                    {
                        _AxleshelfService.AddAxleshe(rightContainer, CZInfo_Mes,clxh,wheelsPosition,newOrOld);   //添加车轴上架记录
                    }

                    //下发出库任务给WCS
                    var configs = _configService.GetConfigsByCategory(CateGoryConst.CONFIG_SYS_IPAddress);
                    var ipAddress = configs.FirstOrDefault(x => x.ConfigKey == SysConfigConst.WCSIPAddress)?.ConfigValue;
                    var ReceiveByWMSTask = configs.FirstOrDefault(x => x.ConfigKey == SysConfigConst.ReceiveTask)?.ConfigValue;
                    if (ReceiveByWMSTask == null || ipAddress == null)
                    {
                        throw new Exception("WMS IP 未配置");
                    }
                    var wmsIpAddrss = ipAddress + ReceiveByWMSTask;

                    var respon = HttpHelper.Post(wmsIpAddrss, JsonConvert.SerializeObject(listTaskDTO));   //http://localhost:9291/api/Task/ReceiveTask,
                    if (respon != null)
                    {
                        WebResponseContent respone = JsonConvert.DeserializeObject<WebResponseContent>(respon.ToString());
                        if (respone.Status)
                        {
                            _unitOfWorkManage.CommitTran();  //提交事务
                            content.OK($"车轮出库任务下发给WCS成功.");
                        }
                        else
                        {
                            _unitOfWorkManage.RollbackTran();  //回滚事务
                            content.Error($"车轮出库任务下发给WCS失败,原因 => {content.Message}");
                        }
                    }
                    else
                    {
                        _unitOfWorkManage.RollbackTran();  //回滚事务
                        throw new Exception("WCS处理失败");
                    }

                    _unitOfWorkManage.CommitTran();  //提交事务
                    content.OK($"车轮出库任务下发给WCS成功.");
                    return content;
                }
                else
                {
                    _unitOfWorkManage.RollbackTran();  //回滚事务
                    return content.Error("未找到可匹配的出库车轮,车型：" + Cartype);
                }
            }
            catch (Exception ex)
            {
                _unitOfWorkManage.RollbackTran();
                return content.Error($"上架失败:{ex.Message}");
            }
        }



        
        private Dt_Task CreateOutTask(Dt_WheelsStock wheelsStock, string CZTM)
        {
            CheckInfo checkInfo = new CheckInfo()
            {
                CarType = wheelsStock.Wheels_CarType,
                MTType = wheelsStock.Wheels_mttype,
                CheckType = wheelsStock.Wheels_Type == "1" ? "1" : "2",
                HubLevel = wheelsStock.Wheels_level.Contains("等级") ? wheelsStock.Wheels_level.Replace("等级", "") : "0",
                CLTM = wheelsStock.Wheels_Num,
                IsCheck = true,
                Standards = wheelsStock.Wheels_NewOrOld
            };


            Dt_Task task = new Dt_Task()
            {
                IsCheck = true,
                CreateDate = DateTime.Now,
                CarType = wheelsStock.Wheels_CarType,
                wheels_gkcc = wheelsStock.Wheels_gkcc,
                Grade = 1,
                CurrentAddress = wheelsStock.Wheels_Location,
                SourceAddress = wheelsStock.Wheels_Location,
                Creater = "System",
                Dispatchertime = DateTime.Now,
                PalletCode = wheelsStock.Wheels_Num,
                Roadway = "SC1",
                TaskNum = _taskRepository.GetTaskNo().Result,
                NextAddress = "2010",
                TargetAddress = "2021",
                TaskState = (int)TaskOutStatusEnum.OutNew,
                TaskType = (int)TaskOutboundTypeEnum.OutWheels,
                task_CZInfo = CZTM,
                task_bak1 = JsonConvert.SerializeObject(checkInfo),
                WheelsLX = wheelsStock.Wheels_ldxh,
                wheels_mttype = wheelsStock.Wheels_mttype,
                WheelsNewOrOld = wheelsStock.Wheels_NewOrOld
            };
            return task;
        }

        
    }
}