using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using WIDESEA_Core.Enums;
using WIDESEA_Core;
using WIDESEA_Model.Models;
using WIDESEA_Core.Helper;
using Microsoft.Extensions.Logging;
using MailKit.Search;
using System.Reflection.Metadata;
using static WIDESEA_ITaskInfoService.ITaskService;
using Org.BouncyCastle.Bcpg;
using WIDESEA_Model.Models.System;
using Newtonsoft.Json;
using Org.BouncyCastle.Asn1.X509;
using Microsoft.AspNetCore.Mvc;

namespace WIDESEA_TaskInfoService
{
    public partial class TaskService
    {
        
    
        public WebResponseContent PalletQueryinventory()
        {
            WebResponseContent content = new WebResponseContent();
            List<Dt_LocationInfo> locationinfoData = _basicService.LocationInfoService.Repository.QueryData(x => x.RoadwayNo=="2" && x.LocationStatus == LocationStatusEnum.Free.ObjToInt() 
            && x.LocationType == (int)LocationTypeEnum.EmptyCube && x.EnableStatus == (int)EnableStatusEnum.Normal);
            if (locationinfoData.Count < 20)
            {
                return content = WebResponseContent.Instance.OK(data: 1);
            }
            else
            {
                return content = WebResponseContent.Instance.OK(data: 3);
            }
        }

        public string ToWCSTask = WIDESEA_Core.Helper.AppSettings.Configuration["ToWCSTask"];
        public WebResponseContent RequestInboundPDA(SaveModel saveModel)
        {

            WebResponseContent content = new WebResponseContent();
            
            //查找货位信息，并修改
            try
            {
                 List<Dt_Task> taskdt = new List<Dt_Task>();
                string barcode = saveModel.MainData["barcode"].ToString();  //条码
                string stationName = saveModel.MainData["stationName"].ToString();  //车型
                string cartnme = saveModel.MainData["cartnme"].ToString();      //名称
                int cartcount = int.Parse(saveModel.MainData["cartcount"].ToString());   //数量
                string barcodemodel = saveModel.MainData["barcodemodel"].ToString();    //车号
                string cartnumber = saveModel.MainData["cartnumber"].ToString();    //车组号

                Dt_StockInfo dt_StockInfo = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == barcode);
                if(dt_StockInfo != null)
                {
                    return content.OK("已有该库存或入库任务，不可重复入库！");
                }
                Dt_Task dttask= BaseDal.QueryFirst(x=>x.PalletCode== barcode);
                if(dttask != null)
                {
                    return content.OK("已有入库任务，不可重复入库！");
                }


                Dt_traycodeinfo _Traycodeinfo = _sys_Traycodeinfo.GetInCacheList(barcode);

                int locationLayer=_dt_pallet.Repository.QueryFirst(x => x.palletnumber == int.Parse(_Traycodeinfo.traycode_type)).pallLayer;

                Dt_LocationInfo newLocation;



                newLocation = _basicService.LocationInfoService.GetLocation(locationLayer.ToString(), 1);
                if (newLocation != null)
                {
                    newLocation.LocationStatus = (int)LocationStatusEnum.Lock;
                    //添加组盘库存信息
                    Dt_StockInfo dt_Stock = new()
                    {
                        PalletCode = barcode,
                        IsFull = true,
                        LocationCode = newLocation.LocationCode,
                        StockStatus = (int)StockStatusEmun.组盘暂存,
                        Creater = "WMS",
                        CreateDate = DateTime.Now,
                        MaterialType =int.Parse(_Traycodeinfo.traycode_type),
                        Wlstatus = (int)InventoryMaterialStatus.待修,
                        Materialweight = cartcount,
                        WagonModel = barcodemodel,      //车号
                        WagonName = cartnme,        //部件名称
                        Wagonnumber = stationName,  //车型
                        Wagongroup= cartnumber          //车组号
                    };

                    //生成入库任务
                    Dt_Task dt_Task = new()
                    {
                        PalletCode = barcode,
                        TaskNum = BaseDal.GetTaskNum(nameof(SequenceEnum.SeqTaskNum)),
                        Roadway = newLocation.RoadwayNo,
                        TaskType = TaskTypeEnum.Inbound.ObjToInt(),
                        TaskStatus = InTaskStatusEnum.InNew.ObjToInt(),
                        SourceAddress = "1084",
                        TargetAddress = newLocation.LocationCode,
                        CurrentAddress = "1084",
                        NextAddress = newLocation.LocationCode,
                        Grade = 1,
                        Depth = newLocation.Depth,
                        MaterialType = (int)InventoryMaterialType.满托,
                        Materialweight = cartcount,
                        WagonModel = barcodemodel,      //车号
                        WagonName = cartnme,        //部件名称
                        Wagonnumber = stationName,  //车型
                        Wagongroup = cartnumber          //车组号
                    };
                    BaseDal.AddData(dt_Task);
                    _stockService.StockInfoService.Repository.AddData(dt_Stock);
                    _basicService.LocationInfoService.UpdateData(newLocation);

                    
                    taskdt.Add(dt_Task);
                    //调取wcs接口传递任务
                    WebResponseContent webResponseContent = HttpHelper.Post<WebResponseContent>(ToWCSTask, taskdt, "入库任务下发");
                    if (webResponseContent.Status)
                    {
                        return content.OK("已添加入库任务");
                    }
                    else
                    {
                        return content.Error("入库任务,下发WCS失败");
                    }
                }
                else
                {
                    return content.Error("已无可用的货架，无法入库");
                }
            }
            catch (Exception ex)
            {
                return content.Error($"入库添加失败，系统错误：{ex.Message}");
                throw;
            }
        }

        public WebResponseContent RequestInboundPDA2(SaveModel saveModel)
        {

            WebResponseContent content = new WebResponseContent();

            //查找货位信息，并修改
            try
            {
                List<Dt_Task> taskdt = new List<Dt_Task>();
                string barcode = saveModel.MainData["barcode"].ToString();  //条码
                string stationName = saveModel.MainData["stationName"].ToString();  //车型
                string cartnme = saveModel.MainData["cartnme"].ToString();      //名称
                int cartcount = int.Parse(saveModel.MainData["cartcount"].ToString());   //数量
                string barcodemodel = saveModel.MainData["barcodemodel"].ToString();    //车号
                string cartnumber = saveModel.MainData["cartnumber"].ToString();    //车组号

                Dt_StockInfo dt_StockInfo = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == barcode);
                if (dt_StockInfo == null)
                {
                    return content.OK("未查找到当前库存，请确认是否是该托盘！");
                }
                Dt_traycodeinfo _Traycodeinfo = _sys_Traycodeinfo.GetInCacheList(barcode);
                dt_StockInfo.IsFull = true;
                dt_StockInfo.StockStatus = (int)StockStatusEmun.已入库;
                dt_StockInfo.MaterialType = int.Parse(_Traycodeinfo.traycode_type);
                dt_StockInfo.Wlstatus = (int)InventoryMaterialStatus.待修;
                dt_StockInfo.Materialweight = cartcount;
                dt_StockInfo.WagonModel = barcodemodel;      //车号
                dt_StockInfo.WagonName = cartnme;        //部件名称
                dt_StockInfo.Wagonnumber = stationName;  //车型
                dt_StockInfo.Wagongroup = cartnumber;          //车组号
                dt_StockInfo.ModifyDate = DateTime.Now;


                Dt_LocationInfo dt_LocationInfo= _basicService.LocationInfoService.GetLocationplatform(dt_StockInfo.LocationCode);
                if(dt_LocationInfo != null)
                {
                    dt_LocationInfo.LocationStatus = LocationStatusEnum.InStock.ObjToInt();

                    _basicService.LocationInfoService.UpdateData(dt_LocationInfo);
                    _stockService.StockInfoService.UpdateData(dt_StockInfo);
                    return content.OK("已更改库存");
                }
                else
                {
                    return content.OK("未能查找到当前托盘的货位信息，请检查库存");
                }


                
            }
            catch (Exception ex)
            {
                return content.Error($"库存更改失败，系统错误：{ex.Message}");
                throw;
            }
        }




        /// <summary>
        /// 空托入库
        /// </summary>
        /// <param name="saveModel"></param>
        /// <returns></returns>
        public WebResponseContent EmptyInbound(GenerateInv saveModel)
        {

            WebResponseContent content = new WebResponseContent();

            //查找货位信息，并修改
            try
            {
                if (saveModel.barcode != null && saveModel.barcode.ToString() != "")
                {
                    Dt_traycodeinfo _Traycodeinfo= _sys_Traycodeinfo.GetInCacheList(saveModel.barcode.ToString());
                    if(_Traycodeinfo!=null)
                    {
                        Dt_StockInfo dt_StockInfo = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == saveModel.barcode.ToString());
                        if (dt_StockInfo != null)
                        {
                            return content.OK("已有该库存或入库任务，不可重复入库！");
                        }

                        Dt_LocationInfo newLocation;
                        newLocation = _basicService.LocationInfoService.GetLocation("", 3);
                        if (newLocation != null)
                        {
                            newLocation.LocationStatus = (int)LocationStatusEnum.PalletLock;
                            //添加组盘库存信息
                            Dt_StockInfo dt_Stock = new()
                            {
                                PalletCode = saveModel.barcode.ToString(),
                                IsFull = false,
                                LocationCode = newLocation.LocationCode,
                                StockStatus = (int)StockStatusEmun.组盘暂存,
                                Creater = "WMS",
                                CreateDate = DateTime.Now,
                                MaterialType = int.Parse(_Traycodeinfo.traycode_type),
                                Wlstatus = (int)InventoryMaterialStatus.空托,
                                Materialweight = 1,
                            };

                            //生成入库任务
                            Dt_Task dt_Task = new()
                            {
                                PalletCode = saveModel.barcode.ToString(),
                                TaskNum = BaseDal.GetTaskNum(nameof(SequenceEnum.SeqTaskNum)),
                                Roadway = newLocation.RoadwayNo,
                                TaskType = TaskTypeEnum.Inbound.ObjToInt(),
                                TaskStatus = InTaskStatusEnum.InNew.ObjToInt(),
                                SourceAddress = saveModel.stationnum.ToString(),
                                TargetAddress = newLocation.LocationCode,
                                CurrentAddress = saveModel.stationnum.ToString(),
                                NextAddress = newLocation.LocationCode,
                                Grade = 1,
                                Depth = newLocation.Depth,
                                MaterialType = (int)InventoryMaterialType.空托,
                                Creater = "WMS",
                                CreateDate= DateTime.Now,
                            };

                            BaseDal.AddData(dt_Task);
                            _stockService.StockInfoService.Repository.AddData(dt_Stock);
                            _basicService.LocationInfoService.UpdateData(newLocation);

                            return content.OK(data: dt_Task);

                        }
                        else
                        {
                            return content.Error("已无可用的货架，无法入库");
                        }

                    }
                    else
                    {
                       /* Dt_traycodeinfo _Traycodeinfo1= new Dt_traycodeinfo();
                        _Traycodeinfo1.traycode_type = "1";
                        _Traycodeinfo1.traycode_createtime=DateTime.Now;
                        _Traycodeinfo1.traycode_staute = 1;
                        _Traycodeinfo1.traycode_code = saveModel.barcode.ToString();*/
                        return content.Error("未找到托盘管理信息");
                    }

                }
                else
                {
                    return content.Error("申请入库的条码为空，入库失败！");
                }
            }
            catch (Exception ex)
            {
                return content.Error($"入库添加失败，系统错误：{ex.Message}");
                throw;
            }
        }


        /// <summary>
        /// 空托入库
        /// </summary>
        /// <param name="saveModel"></param>
        /// <returns></returns>
        public WebResponseContent EmptyInboundPDA(SaveModel saveModel)
        {
            
            WebResponseContent content = new WebResponseContent();
            string barcode = saveModel.MainData["barcode"].ToString();  //条码
            string stationnum = saveModel.MainData["stationnum"].ToString();

            //查找货位信息，并修改
            try
            {
                if (barcode != null && stationnum != "")
                {

                    Dt_traycodeinfo _Traycodeinfo = _sys_Traycodeinfo.GetInCacheList(barcode);
                    if (_Traycodeinfo != null)
                    {
                        Dt_StockInfo dt_StockInfo = _stockService.StockInfoService.Repository.QueryFirst(x => x.PalletCode == barcode);
                        if (dt_StockInfo != null)
                        {
                            return content.OK("已有该库存或入库任务，不可重复入库！");
                        }

                        Dt_LocationInfo newLocation;
                        newLocation = _basicService.LocationInfoService.GetLocation("", 3);
                        if (newLocation != null)
                        {
                            List<Dt_Task> taskdt = new List<Dt_Task>();
                            newLocation.LocationStatus = (int)LocationStatusEnum.PalletLock;
                            //添加组盘库存信息
                            Dt_StockInfo dt_Stock = new()
                            {
                                PalletCode = barcode,
                                IsFull = false,
                                LocationCode = newLocation.LocationCode,
                                StockStatus = (int)StockStatusEmun.组盘暂存,
                                Creater = "WMS",
                                CreateDate = DateTime.Now,
                                MaterialType = int.Parse(_Traycodeinfo.traycode_type),
                                Wlstatus = (int)InventoryMaterialStatus.空托,
                                Materialweight = 1,
                                //WagonModel = _Traycodeinfo.traycode_materiel,
                                //WagonName = _Traycodeinfo.traycode_name,
                                //Wagongroup
                                //Wagonnumber
                            };

                            //生成入库任务
                            Dt_Task dt_Task = new()
                            {
                                PalletCode = barcode,
                                TaskNum = BaseDal.GetTaskNum(nameof(SequenceEnum.SeqTaskNum)),
                                Roadway = newLocation.RoadwayNo,
                                TaskType = TaskTypeEnum.Inbound.ObjToInt(),
                                TaskStatus = InTaskStatusEnum.InNew.ObjToInt(),
                                SourceAddress = stationnum,
                                TargetAddress = newLocation.LocationCode,
                                CurrentAddress = stationnum,
                                NextAddress = newLocation.LocationCode,
                                Grade = 1,
                                Depth = newLocation.Depth,
                                MaterialType = (int)InventoryMaterialType.空托,
                                Creater = "WMS",
                                CreateDate = DateTime.Now,
                            };

                            BaseDal.AddData(dt_Task);
                            _stockService.StockInfoService.Repository.AddData(dt_Stock);
                            _basicService.LocationInfoService.UpdateData(newLocation);
                            taskdt.Add(dt_Task);
                            WebResponseContent webResponseContent = HttpHelper.Post<WebResponseContent>(ToWCSTask, taskdt, "空托入库任务下发");
                            if (webResponseContent.Status)
                            {
                                return content.OK("已添加空托入库任务");
                            }
                            else
                            {
                                return content.Error("空托入库任务,下发WCS失败");
                            }

                        }
                        else
                        {
                            return content.Error("已无可用的货架，无法入库");
                        }

                    }
                    else
                    {
                        
                        return content.Error("未找到托盘管理信息");
                    }

                }
                else
                {
                    return content.Error("申请空托入库的条码为空，入库失败！");
                }
            }
            catch (Exception ex)
            {
                return content.Error($"空托入库添加失败，系统错误：{ex.Message}");
                throw;
            }
        }


        /// <summary>
        /// 检修回库方法
        /// </summary>
        /// <param name="saveModel"></param>
        /// <returns></returns>
        public WebResponseContent MaintenanceStorage(GenerateInv saveModel)
        {
            WebResponseContent content = new WebResponseContent();

            //查找货位信息，并修改
            try
            {

                Dt_StockInfo stocktData = _stockService.StockInfoService.Repository.QueryFirst(x => x.StockStatus == (int)StockStatusEmun.检修中 && x.PalletCode.Contains(saveModel.barcode.ToString()));

                if (stocktData != null)
                {
                    stocktData.StockStatus = (int)StockStatusEmun.检修入库锁定;

                    //生成入库任务
                    Dt_Task dt_Task = new()
                    {
                        PalletCode = saveModel.barcode.ToString(),
                        TaskNum = BaseDal.GetTaskNum(nameof(SequenceEnum.SeqTaskNum)),
                        Roadway = "1",
                        TaskType = TaskTypeEnum.PalletMaintenancein.ObjToInt(),
                        TaskStatus = AGVTaskStatusEnum.AGVin_Executing.ObjToInt(),
                        SourceAddress = saveModel.stationnum.ToString(),
                        TargetAddress = stocktData.LocationCode,
                        CurrentAddress = saveModel.stationnum.ToString(),
                        NextAddress = stocktData.LocationCode,
                        Grade = 1,
                        Depth = 1,
                        MaterialType = (int)InventoryMaterialType.满托,
                        Creater="WMS",
                        CreateDate = DateTime.Now,
                        Materialweight = stocktData.Materialweight,
                        WagonModel = stocktData.WagonModel,      //车号
                        WagonName = stocktData.WagonName,        //部件名称
                        Wagonnumber = stocktData.Wagonnumber,  //车型
                        Wagongroup = stocktData.Wagongroup          //车组号
                    };

                    BaseDal.AddData(dt_Task);
                    _stockService.StockInfoService.Repository.UpdateData(stocktData);
                    //调取wcs接口传递任务
                    //WebResponseContent webResponseContent = HttpHelper.Post<WebResponseContent>(ReceiveWCSTask, dt_Task, "入库任务下发");
                    return content.OK(data: dt_Task);
                }
                else
                {
                    return content.Error($"未找到该托盘条码的库存，申请的托盘条码：{saveModel.barcode.ToString()},站台编号{saveModel.stationnum.ToString()}");
                }
            }
            catch (Exception ex)
            {
                return content.Error($"入库添加失败，系统错误：{ex.Message}");
                throw;
            }
        }

        #region  第二板块
        /// <summary>
        /// 库存信息
        /// </summary>
        /// <returns></returns>
        public object Outbound_inventory()
        {
            //空托数量
            var Location_EmptyPallet = _basicService.LocationInfoService.Repository.QueryData(x=>x.LocationStatus== (int)LocationStatusEnum.Pallet && x.EnableStatus != 3).Count;

            //有货数量
            var Location_occupation = _basicService.LocationInfoService.Repository.QueryData(x => x.LocationStatus == (int)LocationStatusEnum.InStock && x.EnableStatus != 3).Count;

            //空闲数量
            var Location_Free = _basicService.LocationInfoService.Repository.QueryData(x => x.LocationStatus == (int)LocationStatusEnum.Free && x.EnableStatus!=3).Count;

            //待检数量
            var Stock_inspected = _stockService.StockInfoService.Repository.QueryData(x => x.Wlstatus == (int)InventoryMaterialStatus.待修 || x.Wlstatus == (int)InventoryMaterialStatus.半检修).Count;

            //合格数量
            var Stock_qualified = _stockService.StockInfoService.Repository.QueryData(x => x.Wlstatus == (int)InventoryMaterialStatus.合格).Count;

            var data = new
            {
                Location_EmptyPallet,
                Location_occupation,
                Location_Free,
                Stock_inspected,
                Stock_qualified,
            };

            return data;
        }



        /// <summary>
        /// 获取货位信息
        /// </summary>
        /// <param name="area"></param>
        /// <returns></returns>
        public object GetLocationStatu2()
        {
            var data = _basicService.LocationInfoService.Repository.QueryData(x => x.LocationName != "99").ToList();

            var group1 = data.Where(x => x.Row == 1 && x.Layer == 6).ToList();
            var group2 = data.Where(x => x.Row == 1 && x.Layer == 5).OrderBy(x => x.Column).ToList();
            var group3 = data.Where(x => x.Row == 1 && x.Layer == 4).OrderBy(x => x.Column).ToList();
            var group4 = data.Where(x => x.Row == 1 && x.Layer == 3).OrderBy(x => x.Column).ToList();
            var group5 = data.Where(x => x.Row == 1 && x.Layer == 2).OrderBy(x => x.Column).ToList();
            var group6 = data.Where(x => x.Row == 1 && x.Layer == 1).OrderBy(x => x.Column).ToList();

            var group7 = data.Where(x => x.Row == 2 && x.Layer == 6).OrderBy(x => x.Column).ToList();
            var group8 = data.Where(x => x.Row == 2 && x.Layer == 5).OrderBy(x => x.Column).ToList();
            var group9 = data.Where(x => x.Row == 2 && x.Layer == 4).OrderBy(x => x.Column).ToList();
            var group10 = data.Where(x => x.Row == 2 && x.Layer == 3).OrderBy(x => x.Column).ToList();
            var group11 = data.Where(x => x.Row == 2 && x.Layer == 2).OrderBy(x => x.Column).ToList();
            var group12 = data.Where(x => x.Row == 2 && x.Layer == 1).OrderBy(x => x.Column).ToList();

            var combinedGroups = group1.Concat(group2)
                           .Concat(group3)
                           .Concat(group4)
                           .Concat(group5)
                           .Concat(group6)
                           .Concat(group7)
                           .Concat(group8)
                           .Concat(group9)
                           .Concat(group10)
                           .Concat(group11)
                           .Concat(group12)
                           .ToList();
            List<LocationCol2> col2s = new List<LocationCol2>();
            foreach (var item in combinedGroups)
            {
                col2s.Add(new LocationCol2()
                {
                    index = item.LocationCode,
                    location_state = item.LocationStatus.ToString(),
                    location_lock = item.EnableStatus == 3 ? true : false,
                });
            }


            var Stock_inspected = _stockService.StockInfoService.Repository.QueryData(x => x.Wlstatus == (int)InventoryMaterialStatus.待修
            || x.Wlstatus == (int)InventoryMaterialStatus.已修 || x.Wlstatus == (int)InventoryMaterialStatus.合格 || x.Wlstatus == (int)InventoryMaterialStatus.半检修);

            foreach (var item in col2s.Where(x => x.location_state == "2").ToList())
            {
                Dt_StockInfo stocktData = Stock_inspected.Find(x => x.LocationCode == item.index);
                if(stocktData != null)
                {
                    if (stocktData.Wlstatus == 0 || stocktData.Wlstatus == 4)
                    {
                        item.location_state = "11"; //待修状态
                    }
                    else if (stocktData.Wlstatus == 1 || stocktData.Wlstatus == 2)
                    {
                        item.location_state = "12"; //已修状态
                    }
                }
                
            }

            var kd= col2s.Where(x=>x.location_state=="99").ToList();

            return col2s;
        }

        public class LocationLayer
        {
            public int index { get; set; }
            public List<LocationRow> rows { get; set; }
        }
        public class LocationRow
        {
            public int index { get; set; }
            public List<LocationCol> cols { get; set; }
        }

        public class LocationCol
        {
            public int index { get; set; }
            /// <summary>
            /// 检测柜状态
            /// </summary>
            public string remark { get; set; }
            /// <summary>
            /// 货位状态
            /// </summary>
            public string location_state { get; set; }
            /// <summary>
            /// 锁定状态
            /// </summary>
            public bool location_lock { get; set; }
        }

        public class LocationCol2
        {
            public string index { get; set; }
            /// <summary>
            /// 货位状态
            /// </summary>
            public string location_state { get; set; }
            /// <summary>
            /// 锁定状态
            /// </summary>
            public bool location_lock { get; set; }
        }


        #endregion
    }
}