using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Web.Http;
using System.Xml.Linq;
using System.Xml;
using static HH.WCS.Mobox3.pinggao.models.SapRoot;
using HH.WCS.Mobox3.pinggao;
using Newtonsoft.Json.Linq;
using static HH.WCS.Mobox3.pinggao.api.ApiModel;
using System.Reflection;
using HH.WCS.Mobox3.pinggao.api;
using static HH.WCS.Mobox3.pinggao.api.OtherModel;
using static HH.WCS.Mobox3.pinggao.api.ApibackModel;
using HH.WCS.Mobox3.pinggao.models;
using static HH.WCS.Mobox3.pinggao.models.DAPING;
using HH.WCS.Mobox3.pinggao.util;
using SqlSugar;
using System.Diagnostics;

namespace HH.WCS.Mobox3.pinggao.api
{
    public class WmsSapController : System.Web.Http.ApiController
    {
        /// <summary>
        /// 出庫任務列表
        /// </summary>
        /// <returns></returns>
        public DPList DpRecord(DpDto dpDto)
        {
            var response = new DPList
            {
                DpList = new List<DP> { }
            };
            if (string.IsNullOrEmpty(dpDto.Code))
            {
                LogHelper.Info("货位信息不能为空" );
                return response;
            }
            var db = new SqlHelper<object>().GetInstance();
            var list =db.Queryable<TN_DPRECORD>().Where(s=>s.S_LOCATION== dpDto.Code).OrderByDescending(s=>s.T_CREATE).ToList();
            var tasksList = list.Select(t => new DP
            {
                S_NO = t.S_NO,
                S_WLBM = t.S_WLBM,
                S_WLMC = t.S_WLMC,
                N_COUNT = t.N_COUNT,
                S_LOCATION = t.S_LOCATION
            }).ToList();
            response.DpList = tasksList;
            return response;

        }
        #region 大屏数据接口
            /// <summary>
            /// 大屏数据
            /// </summary>
            /// <returns></returns>
        public BarChartResponse InOut(){

            var response = new BarChartResponse
            {
                OutboundData = new List<BarChartData>
                {
                },
                InboundData = new List<BarChartData>
                {

                },
                CKNData = new List<NB> { },
                ListTask = new List<Tasks> { },
                Inttbounddjcount = 0,
                Outtbounddjcount=0,
                IntodayCount = 0,
                OuttodayCount = 0

            };

            var db = new SqlHelper<object>().GetInstance();
            #region 出库
            // 1. 获取当前年份（或指定年份）
            int year = DateTime.Now.Year; // 如2023

            // 2. 生成1-12月所有月份（确保完整性）
            var allMonths = Enumerable.Range(1, 12)
                .Select(m => new DateTime(year, m, 1).ToString("MM"))
                .ToList();

            //var allMonths = Enumerable.Range(1, 12).ToList();
            // 3. 查询数据库获取出库数据（按月份分组统计）
            var outboundCounts = db.Queryable<WCSTask>()
                .Where(a => a.S_TYPE.Contains("出库") &&a.N_B_STATE==3&& a.T_END_TIME != null&&a.T_END_TIME.Value.Year== year)
                .ToList() // 加载到内存
                .GroupBy(a => a.T_END_TIME.Value.ToString("MM")) // 按月份分组
                .ToDictionary(g => g.Key, g => g.Count()); // 转为字典（月份:记录数）

            // 3. 构建完整1-12月数据（缺失月份补0）
            var outboundData = allMonths.Select(month => new BarChartData
            {
                Month = int.Parse(month),
                Count = outboundCounts.TryGetValue(month, out var count) ? count : 0
            }).ToList();
            response.OutboundData = outboundData;
            #endregion
            #region 入库
            var inttboundCounts = db.Queryable<WCSTask>()
           .Where(a => a.S_TYPE.Contains("入库") && a.N_B_STATE == 3 && a.T_END_TIME != null && a.T_END_TIME.Value.Year == year)
           .ToList() // 加载到内存
           .GroupBy(a => a.T_END_TIME.Value.ToString("MM")) // 按月份分组
           .ToDictionary(g => g.Key, g => g.Count()); // 转为字典（月份:记录数）
            var intboundData = allMonths.Select(month => new BarChartData
            {
                Month = int.Parse(month),
                Count = inttboundCounts.TryGetValue(month, out var count) ? count : 0
            }).ToList();
            response.InboundData = intboundData;
            #endregion
            #region 未完成单据量
            var Inttbounddjcount = db.Queryable<TN_Inbound_Order>().Where(s=>s.N_B_STATE==0).Count();
            var Outtbounddjcount = db.Queryable<TN_Ll_Order>().Where(s=>s.N_B_STATE==0).Count();
            var today = DateTime.Today;
            var tomorrow = today.AddDays(1);

            var IntodayCount = db.Queryable<WCSTask>()
                .Where(s => s.N_B_STATE == 3 && s.S_TYPE.Contains("入库")&&
                            s.T_END_TIME >= today &&
                            s.T_END_TIME < tomorrow).Count();
            var OuttodayCount = db.Queryable<WCSTask>()
            .Where(s => s.N_B_STATE == 3 && s.S_TYPE.Contains("出库") &&
                        s.T_END_TIME >= today &&
                        s.T_END_TIME < tomorrow).Count();
            response.Inttbounddjcount = Inttbounddjcount;
            response.Outtbounddjcount = Outtbounddjcount;
            response.OuttodayCount = OuttodayCount;
            response.IntodayCount = IntodayCount;
            #endregion
            #region 任务列表
            var tasklist = db.Queryable<WCSTask>().Where(s => s.N_B_STATE != 2).Select(s => new { s.S_CNTR_CODE, s.S_START_AREA, s.S_END_AREA, s.S_B_STATE }).Take(5).ToList() ;
            var tasksList = tasklist.Select(t => new Tasks
            {
                S_CNTR_CODE = t.S_CNTR_CODE,
                S_START_AREA = t.S_START_AREA,
                S_END_AREA = t.S_END_AREA,
                S_B_STATE = t.S_B_STATE
            }).ToList();
            response.ListTask = tasksList;
            #endregion


            #region 仓库库内审核
            var ManCount = db.Queryable<CntrItemRel>()
                           .Where(s => s.S_CNTR_TYPE == "满托")
                           .GroupBy(s => s.S_CNTR_CODE)
                           .Select(s => new { s.S_CNTR_CODE })
                           .Count();
            var ManName = "满托盘";

            var BanCount = db.Queryable<CntrItemRel>()
                           .Where(s => s.S_CNTR_TYPE == "半托")
                           .GroupBy(s => s.S_CNTR_CODE)
                           .Select(s => new { s.S_CNTR_CODE })
                           .Count();
            var BanName = "半托盘";
            //所有容器的数量
            int allCntrcout = db.Queryable<LocCntrRel>().Count();
            //所有容器物料数量
            int alltprcout = db.Queryable<CntrItemRel>()
                     .GroupBy(s => s.S_CNTR_CODE)
                     .Select(s => new { s.S_CNTR_CODE })
                     .Count();

            var KTCount = allCntrcout - alltprcout;
            var KTName = "空托盘";

            int alllocationcout = db.Queryable<Location>().Count();
            var KHWCount = alllocationcout - allCntrcout;
            var KHWName = "空货位";

            var list = new List<NB>
        {
            new NB { Name = ManName, Count = ManCount },
            new NB { Name = BanName, Count = BanCount },
            new NB { Name = KTName, Count = KTCount },
            new NB { Name = KHWName, Count = KHWCount }
        };
            response.CKNData = list;
            #endregion
            return response;
        
        }

            
        #endregion

        /// <summary>
        /// 供应商接收接口获取
        /// </summary>
        /// <param name="xmlData"></param>
        /// <returns></returns>
        [HttpPost]
        public GYSReturnRoot.Root GYSReceiveXmlData([FromBody] GYSDto.Root xmlData)
        {
            #region xml数据接收转数组

            //LogHelper.Info("供应商接收接口：" + JsonConvert.SerializeObject(xmlData));

            ////接收xml数据
            //XmlDocument xmlDoc = new XmlDocument();
            //xmlDoc.LoadXml(xmlData.ToString());

            //// 将 XmlDocument 转换为 JSON 字符串
            //JObject jsonObject = JsonConvert.DeserializeObject<JObject>(JsonConvert.SerializeXmlNode(xmlDoc));

            //// 处理特定字段，强制转换为数组
            //WmsSpaHelper.EnsureArrayFormats(jsonObject, "ITEM");
            //// 反序列化为RootWithArray
            //var data = JsonConvert.DeserializeObject<OrderDto.Root>(jsonObject.ToString());
            #endregion

            #region 外采入库业务流程
            GYSReturnRoot.Root simpleResult = WmsSpaHelper.GYS_In(xmlData);
            //接收返回参数 生成sap对接文档返回格式
            //var json = WmsSpaHelper.GetJsonResult(simpleResult.WLPZBH, simpleResult.resultCode.ToString(), simpleResult.resultMsg);

            #endregion
            #region  返回xml
            //string xml = JsonConvert.DeserializeXmlNode(json, "root").OuterXml;
            ////返回json
            //var response = new HttpResponseMessage()
            //{
            //    Content = new StringContent(xml, Encoding.UTF8, "application/xml")
            //};
            //return response;
            return simpleResult;
            #endregion
        }


        /// <summary>
        /// 生产订单信息获取
        /// </summary>
        /// <param name="xmlData"></param>
        /// <returns></returns>
        [HttpPost]
        public Orderback.Root OrderReceiveXmlData([FromBody] OrderDto.Root xmlData)
        {
            #region xml数据接收转数组

            //LogHelper.Info("生产订单接收接口：" + JsonConvert.SerializeObject(xmlData));

            ////接收xml数据
            //XmlDocument xmlDoc = new XmlDocument();
            //xmlDoc.LoadXml(xmlData.ToString());

            //// 将 XmlDocument 转换为 JSON 字符串
            //JObject jsonObject = JsonConvert.DeserializeObject<JObject>(JsonConvert.SerializeXmlNode(xmlDoc));

            //// 处理特定字段，强制转换为数组
            //WmsSpaHelper.EnsureArrayFormats(jsonObject, "ITEM");
            //// 反序列化为RootWithArray
            //var data = JsonConvert.DeserializeObject<OrderDto.Root>(jsonObject.ToString());
            #endregion

            #region 外采入库业务流程
            Orderback.Root simpleResult = WmsSpaHelper.Mater_In(xmlData);
            //接收返回参数 生成sap对接文档返回格式
            //var json = WmsSpaHelper.GetJsonResult(simpleResult.WLPZBH, simpleResult.resultCode.ToString(), simpleResult.resultMsg);

            #endregion
            #region  返回xml
            //string xml = JsonConvert.DeserializeXmlNode(json, "root").OuterXml;
            ////返回json
            //var response = new HttpResponseMessage()
            //{
            //    Content = new StringContent(xml, Encoding.UTF8, "application/xml")
            //};
            //return response;
            return simpleResult;
            #endregion
        }
        /// <summary>
        /// 主物料信息获取
        /// </summary>
        /// <param name="xmlData"></param>
        /// <returns></returns>

        [HttpPost]
        public WLReturnRoot.Root MaterReceiveXmlData([FromBody] MaterDto.Root xmlData)
        {
            

            #region 外采入库业务流程
            WLReturnRoot.Root simpleResult = WmsSpaHelper.Mater_In(xmlData);
         

            var json = JsonConvert.SerializeObject(simpleResult);
            return simpleResult;
            #endregion
        }

        /// <summary>
        /// 外采收货
        /// </summary>
        /// <param name="xmlData"></param>
        /// <returns></returns>

        [HttpPost]
        public WcReturnRoot.Root WCReceiveXmlData([FromBody] SapRoot.Root xmlData)
        {
            #region xml数据接收转数组
            //LogHelper.Info("外采收货接口：" + JsonConvert.SerializeObject(xmlData));
            //接收xml数据
            //XmlDocument xmlDoc = new XmlDocument();
            //xmlDoc.LoadXml(xmlData.ToString());

            // 将 XmlDocument 转换为 JSON 字符串
            //JObject jsonObject = JsonConvert.DeserializeObject<JObject>(JsonConvert.SerializeXmlNode(xmlDoc));

            // 处理特定字段，强制转换为数组
            //WmsSpaHelper.EnsureArrayFormat(jsonObject, "ITME", "ITEM1");
            // 反序列化为RootWithArray
            //var data = JsonConvert.DeserializeObject<Root>(jsonObject.ToString());
            #endregion

            #region 外采入库业务流程
            List<SimpleResult> simpleResult = WmsSpaHelper.Inbound_Order_In(xmlData);
            //接收返回参数 生成sap对接文档返回格式
            List<WcReturnRoot.ITEM> wcReturnRoots = new List<WcReturnRoot.ITEM>();
            foreach (var item in simpleResult)
            {
                WcReturnRoot.ITEM wcReturnRoot = new WcReturnRoot.ITEM();
                wcReturnRoot.WLPZH = item.WLPZBH;
                wcReturnRoot.WLPZND = item.WLPZND;
                wcReturnRoot.MSGCODE = item.resultCode;
                wcReturnRoot.MSGDESP = item.resultMsg;
                wcReturnRoots.Add(wcReturnRoot);
            }
            //var json = WmsSpaHelper.GetJsonResult(simpleResult.WLPZBH, simpleResult.resultCode.ToString(), simpleResult.resultMsg);
            // 完整嵌套实例化
            var result = new WcReturnRoot.Root
            {
                ROOT = new WcReturnRoot.ROOT
                {
                    ITEM = wcReturnRoots
                }
            };
            #endregion
            #region  返回xml
            var json = JsonConvert.SerializeObject(result);
            //string xml = JsonConvert.DeserializeXmlNode(json, "ROOT").OuterXml;
            ////返回json
            //var response = new HttpResponseMessage()
            //{
            //    Content = new StringContent(xml, Encoding.UTF8, "application/xml")
            //};
            return result;
            #endregion
        }

        /// <summary>
        /// 内采入库/出库
        /// </summary>
        /// <param name="xmlData"></param>
        /// <returns></returns>

        [HttpPost]
        public WcReturnRoot.Root NCReceiveXmlData([FromBody] NcDto.Root xmlData)
        {
            #region xml数据接收转数组


            //NcDto.ROOT rOOT = new NcDto.ROOT();
            //rOOT.WLPZ = new NcDto.WLPZ();
            //LogHelper.Info("内采收货接口：" + JsonConvert.SerializeObject(xmlData));

            ////接收xmloo
            //XmlDocument xmlDoc = new XmlDocument();
            //xmlDoc.LoadXml(xmlData.ToString());

            //// 将 XmlDocument 转换为 JSON 字符串
            //JObject jsonObject = JsonConvert.DeserializeObject<JObject>(JsonConvert.SerializeXmlNode(xmlDoc));

            //// 处理特定字段，强制转换为数组
            //WmsSpaHelper.EnsureArrayFormat(jsonObject, "ITME", "ITEM1");
            //// 反序列化为RootWithArray
            //var data = JsonConvert.DeserializeObject<NcDto.Root>(jsonObject.ToString());

            //// SimpleResult simpleResult = WmsSpaHelper.OtherOut_Order_Ins(data); 


            //#endregion
            //#region  返回xml
            //string xml = JsonConvert.DeserializeXmlNode(json, "ROOT").OuterXml;
            ////返回json
            //var response = new HttpResponseMessage()
            //{
            //    Content = new StringContent(xml, Encoding.UTF8, "application/xml")
            //};
            //return response;

            #endregion

            List<SimpleResult> simpleResult = WmsSpaHelper.NCInbound_Order_In(xmlData);
            //接收返回参数 生成sap对接文档返回格式
            List<WcReturnRoot.ITEM> wcReturnRoots = new List<WcReturnRoot.ITEM>();
            foreach (var item in simpleResult)
            {
                WcReturnRoot.ITEM wcReturnRoot = new WcReturnRoot.ITEM();
                wcReturnRoot.WLPZH = item.WLPZBH;
                wcReturnRoot.WLPZND = item.WLPZND;
                wcReturnRoot.MSGCODE = item.resultCode;
                wcReturnRoot.MSGDESP = item.resultMsg;
                wcReturnRoots.Add(wcReturnRoot);
            }
            //var json = WmsSpaHelper.GetJsonResult(simpleResult.WLPZBH, simpleResult.resultCode.ToString(), simpleResult.resultMsg);
            // 完整嵌套实例化
            var result = new WcReturnRoot.Root
            {
                ROOT = new WcReturnRoot.ROOT
                {
                    ITEM = wcReturnRoots
                }
            };
            #region  返回xml
            var json = JsonConvert.SerializeObject(result);
            return result;
            #endregion

        }
        /// <summary>
        /// 其他出入库[FromBody] XElement xmlData
        /// </summary>
        /// <param name="xmlData"></param>
        /// <returns></returns>
        [HttpPost]
        public OtherReturnRoot.Root OtherReceiveXmlData([FromBody] otherDto.Root xmlData)
        {
           
            #region 其他出入库业务流程
            List<SimpleResult> simpleResult = WmsSpaHelper.Otherbound_Order_In(xmlData);

            #endregion
            #region  返回xml
            #endregion
            List<OtherReturnRoot.ITEM> wcReturnRoots = new List<OtherReturnRoot.ITEM>();
            foreach (var item in simpleResult)
            {
                OtherReturnRoot.ITEM wcReturnRoot = new OtherReturnRoot.ITEM();
                wcReturnRoot.WLPZBH = item.WLPZBH;
                wcReturnRoot.ND = item.WLPZND;
                wcReturnRoot.MSGCODE = item.resultCode;
                wcReturnRoot.MSGDESP = item.resultMsg;
                wcReturnRoots.Add(wcReturnRoot);
            }
            var result = new OtherReturnRoot.Root
            {
                ROOT = new OtherReturnRoot.ROOT
                {
                    ITEM = wcReturnRoots
                }
            };
            return result;
            // 处理XML数据
            // ...
        }




        /// <summary>
        /// 码盘入库
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        [HttpPost]
        public SimpleResult InboundOrderSorting(MPSorting model)
        {
            return WmsSpaHelper.InboundOrderSorting(model);
        }

        /// <summary>
        /// pda分拣
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        [HttpPost]
        public Task<SimpleResult> OutboundOrderSorting(FJSorting model)
        {
            return WmsSpaHelper.OutboundOrderSorting(model);
        }

        /// <summary>
        /// 空托出入库
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        [HttpPost]
        public Task<SimpleResult> InOutKT(KtSorting model)
        {
            return WmsSpaHelper.KtSorting(model);
        }


        /// <summary>
        /// 生产订单领料单（出库单）
        /// </summary>
        /// <param name="xmlData"></param>
        /// <returns></returns>

        //[HttpPost]
        //public HttpResponseMessage ReceiveXmlCKData([FromBody] XElement xmlData)
        //{
        //    #region xml数据接收转数组
        //    ROOT rOOT = new ROOT();
        //    rOOT.WLPZ = new WLPZ();
        //    LogHelper.Info("外采收货接口：" + xmlData.ToString());

        //    //接收xml数据
        //    XmlDocument xmlDoc = new XmlDocument();
        //    xmlDoc.LoadXml(xmlData.ToString());

        //    // 将 XmlDocument 转换为 JSON 字符串
        //    JObject jsonObject = JsonConvert.DeserializeObject<JObject>(JsonConvert.SerializeXmlNode(xmlDoc));

        //    // 处理特定字段，强制转换为数组

        //    //WmsSpaHelper.EnsureArrayFormat(jsonObject, "ITME");
        //    WmsSpaHelper.EnsureArrayFormat(jsonObject["ROOT"]["SCDDLL"] as JObject, "ITEM");
        //    // 反序列化为RootWithArray
        //    var data = JsonConvert.DeserializeObject<CKDdto.Root>(jsonObject.ToString());
        //    #endregion

        //    #region 出库业务流程
        //    var json = WmsSpaHelper.Out_Order_In(data);
        //    //接收返回参数 生成sap对接文档返回格式
        //    //var json = WmsSpaHelper.GetJsonResult(simpleResult.WLPZBH, simpleResult.resultCode.ToString(), simpleResult.resultMsg);

        //    #endregion
        //    #region  返回xml
        //    string xml = JsonConvert.DeserializeXmlNode(json, "root").OuterXml;
        //    //返回json
        //    var response = new HttpResponseMessage()
        //    {
        //        Content = new StringContent(xml, Encoding.UTF8, "application/xml")
        //    };
        //    return response;
        //    #endregion
        //}



        /// <summary>
        /// 生产订单领料单(生成领料单)
        /// </summary>
        /// <param name="xmlData"></param>
        /// <returns></returns>

        [HttpPost]
        public LLDReturnRoot.Root LLDReceiveXmlData([FromBody] CKDdto.Root xmlData)
        {
            //Stopwatch sw = new Stopwatch();
            //sw.Start();
            #region xml数据接收转数组
            //LogHelper.Info("生产订单领料单(生成领料单)接口：" + JsonConvert.SerializeObject(xmlData));


            #endregion

            #region 出库业务流程
            return WmsSpaHelper.Out_Order_Ins(xmlData);


            //sw.Stop();
            //long elapsedMilliseconds = sw.ElapsedMilliseconds;
            //LogHelper.Info("生产订单领料单(生成领料单)返回时长：" + elapsedMilliseconds);

            #endregion
        }

        /// <summary>
        /// 领料单生成出库单
        /// </summary>
        /// <param name="xmlData"></param>
        /// <returns></returns>

        [HttpPost]
        public WeiLiResult GetLLDReceiveXmlData(LLDDto dto)
        {


            var json = WmsSpaHelper.Out_Order_Inss(dto.S_NO);


            return json;
        }
        #region wms-sap接口


        /// <summary>
        /// 外采入库/内采入库/计划外退料入库审核接口
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        [HttpPost]
        public async Task<SimpleResult> WcInboundOrderAccieve(WcRkDto model)
        {
            return await WmsSpaHelper.NcRkBacking(model);
        }


        ///// <summary>
        ///// 内采收货入库接口
        ///// </summary>
        ///// <param name="model"></param>
        ///// <returns></returns>
        //[HttpPost]
        //public async Task<SimpleResult> NcInboundOrderAccieve(WcRkDto model)
        //{
        //    return await WmsSpaHelper.NcRkBacking(model);
        //}
        #endregion


        /// <summary>
        /// 测试接口
        /// </summary>
        /// <param name="xmlData"></param>
        /// <returns></returns>
        [HttpPost]
        public HttpResponseMessage cesReceiveXmlData([FromBody] XElement xmlData)
        {
            string xmlDatas = "{\r\n  \"ROOT\": {\r\n    \"ITEM\": {\r\n      \"KEY\": \"唯一标识\",\r\n      \"WLPZBH\": \"物料凭证号\",\r\n    " +
               "  \"WLPZND\": \"物料凭年度\",\r\n      \"MSGCODE\": \"1\",\r\n      \"MSGDESP\": \"失败原因或者成功信息字符长度255\"\r\n    }\r\n  }\r\n}";
            var data = JsonConvert.DeserializeObject<ReturnWcBcak.Root>(xmlDatas);

            string xml = JsonConvert.DeserializeXmlNode(xmlDatas, "").OuterXml;
            //返回json
            var response = new HttpResponseMessage()
            {
                Content = new StringContent(xml, Encoding.UTF8, "application/xml")
            };
            return response;

        }
    }


}