using SqlSugar;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Linq;
using Newtonsoft.Json;
using Rhea.Common.Authorization;
using Newtonsoft.Json.Linq;
using Tiger.Model.Minsun;
using System.Globalization;
using System.Data;
using System.Text.RegularExpressions;
using System.Text;
using System.DirectoryServices.ActiveDirectory;
using Dm;
using Tiger.Model.DigitalTwin;
using System.IO;
using System.Net;
using Rhea.Common;
using static Tiger.Model.Minsun.IqcManagementSides;

namespace Tiger.Business.WMS
{
    public static partial class Shelf
    {
        public static long UserId { get; set; }
        public static string _shelfApiUrl { get; set; } = GetSysCodeText("ShelfSetting", "ShelfApiUrl");
        private static string _shelfLightColor { get; set; } = GetSysCodeText("ShelfSetting", "ShelfLightColor");


        /// <summary>
        /// 上架
        /// </summary>
        /// <param name="operateInput"></param>
        /// <returns></returns>
        public static async Task<Result<ShelfOperateOutput>> UpShelf(ShelfOperateInput operateInput)
        {
            Result<ShelfOperateOutput> result = new(Result.Flags.Success, $"成功上架");
            string uniqueID = Guid.NewGuid().ToString();
            // 1. 发送上架指令
            // 准备 POST 请求 body 参数

            var data1 = new
            {
                shelfNo = operateInput.ShelfNo,
                operateType = 1,
                pdaid = string.IsNullOrEmpty(operateInput.PdaId) ? UserId.ToString() : operateInput.PdaId,
                keepSeconds = 30,
                uniqueNumber = uniqueID
            };

            string apiUrl1 = _shelfApiUrl + "/OperateConfig";
            var jsonString1 = JsonConvert.SerializeObject(data1);

            Result<JObject> result1 = await PostShelfApi(apiUrl1, jsonString1);
            if (result1.Flag != Result.Flags.Success)
            {
                result.Flag = Result.Flags.Failed;
                result.Message = result1.Message;
                return result;
            }
            JObject resp1 = result1.Data;
            ShelfApiResult apiResult = new ShelfApiResult();
            apiResult.IsSuccess = resp1["OperateConfigResult"]["IsSuccess"].ToString();
            apiResult.ItemCode = resp1["OperateConfigResult"]["ItemCode"].ToString();
            apiResult.ResultValue = resp1["OperateConfigResult"]["ResultValue"].ToString();
            apiResult.Type = resp1["OperateConfigResult"]["Type"].ToString();

            //定义返回参数
            ShelfOperateOutput shelfOperateOutput = new ShelfOperateOutput();

            // 如果上架操作指令成功
            if (apiResult.IsSuccess.ToUpper() == "TRUE")
            {
                // 2. 发送 GetOperateChuteChangeInfo 指令，获取上架位置（ledAddr）及 uniqueNumber
                // 准备 POST 请求 body 参数
                var data2 = new
                {
                    shelfNo = operateInput.ShelfNo,
                    operateType = operateInput.OperateType
                };

                string apiUrl2 = _shelfApiUrl + "/GetOperateChuteChangeInfo";
                var jsonString2 = JsonConvert.SerializeObject(data2);

                shelfOperateOutput.IsSuccess = "FALSE";
                DateTime timeStart = DateTime.Now;
                TimeSpan timeSpan = DateTime.Now - timeStart;
                while (shelfOperateOutput.IsSuccess.ToUpper() != "TRUE" && timeSpan.TotalSeconds < 30)
                {
                    DateTime timeEnd = DateTime.Now;
                    timeSpan = DateTime.Now - timeStart;

                    Result<JObject> result2 = await PostShelfApi(apiUrl2, jsonString2);
                    if (result2.Flag == Result.Flags.Success)
                    {
                        JObject resp2 = result2.Data;

                        shelfOperateOutput.IsSuccess = resp2["GetOperateChuteChangeInfoResult"]["IsSuccess"].ToString();
                        string resultValue = resp2["GetOperateChuteChangeInfoResult"]["ResultValue"].ToString();

                        if (shelfOperateOutput.IsSuccess.ToUpper() == "TRUE" && !String.IsNullOrEmpty(resultValue))
                        {
                            JObject jo = JObject.Parse(resultValue);
                            shelfOperateOutput.ShelfNo = jo["shelfNo"].ToString();
                            shelfOperateOutput.OperateType = jo["operateType"].ToString();
                            shelfOperateOutput.LedAddr = jo["ledAddr"].ToString();
                            shelfOperateOutput.PdaId = jo["pdaid"].ToString();
                            shelfOperateOutput.UniqueNumber = jo["uniqueNumber"].ToString();

                            if (uniqueID != shelfOperateOutput.UniqueNumber)
                            {
                                shelfOperateOutput.IsSuccess = "False";
                                shelfOperateOutput.Message = "UniqueNumber 不同";
                            };

                            if (operateInput.ShelfNo != shelfOperateOutput.ShelfNo)
                            {
                                shelfOperateOutput.IsSuccess = "False";
                                shelfOperateOutput.Message = "ShelfNo 不同";
                            };
                        }
                    }
                }

                // 3. 结束上架
                var data3 = new
                {
                    shelfNo = data1.shelfNo,
                    operateType = 7,
                    pdaid = data1.pdaid,
                    keepSeconds = 30,
                    uniqueNumber = data1.uniqueNumber,
                };
                string apiUrl3 = _shelfApiUrl + "/OperateConfig";
                var jsonString3 = JsonConvert.SerializeObject(data3);
                Result<JObject> result3 = await PostShelfApi(apiUrl3, jsonString3);
                if (result3.Flag != Result.Flags.Success)
                {
                    result.Flag = Result.Flags.Failed;
                    result.Message = result3.Message;
                    return result;
                }
                JObject resp3 = result3.Data;
                if (timeSpan.TotalSeconds >= 30)
                {
                    result.Flag = Result.Flags.Failed;
                    result.Message = $"上架操作超时";
                    return result;
                }
            }

            // 更新库位代码，LocationCode
            WMS_LOCATION locOut = await Biz.Db.Queryable<WMS_LOCATION>().Where(t => t.RACKCODE == shelfOperateOutput.ShelfNo
                                     && t.LedAddr.ToString() == shelfOperateOutput.LedAddr).FirstAsync();
            if (locOut != null)
                shelfOperateOutput.LocationCode = locOut.LOCATIONCODE;
            result.Data = shelfOperateOutput;
            return result;

        }

        // 读取数据字典，根据CodeType,CodeValue获取参数Text
        private static string GetSysCodeText(string codeType, string codeValue)
        {
            var code = Biz.Db.Queryable<Sys_Code>().Where(x => x.CodeType.ToUpper() == codeType && x.Value.ToUpper() == codeValue).First();
            return code?.Text;
        }

        // Http Post ShelfApi
        private static async Task<Result<JObject>> PostShelfApi(string apiUrl, string strJson)
        {
            Result<JObject> result = new(Result.Flags.Success, $"货架API返回成功");
            HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.Create(apiUrl);
            httpWebRequest.ContentType = "application/json;charset=utf-8";
            httpWebRequest.Method = "POST";
            httpWebRequest.Timeout = 10000;

            byte[] btBodys = Encoding.UTF8.GetBytes(strJson);
            httpWebRequest.ContentLength = btBodys.Length;
            //Logger.Default.Info(string.Format("智能货架：开始请求{0}，参数{1}", apiUrl, strJson));
            try
            {
                httpWebRequest.GetRequestStream().Write(btBodys, 0, btBodys.Length);
            }
            catch (Exception ex)
            {
                Logger.Default.Info(string.Format("智能货架：请求异常；返回信息：{0}", JsonConvert.SerializeObject(ex)));
                result.Flag = Result.Flags.Failed;
                result.Message = $"智能货架：请求异常；返回信息：{JsonConvert.SerializeObject(ex)}";
                return result;
            }

            HttpWebResponse httpResponse;
            string respnsetContent;
            try
            {
                httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
                if (httpResponse.StatusCode != HttpStatusCode.OK)
                {
                    result.Flag = Result.Flags.Failed;
                    result.Message = $"智能货架API通讯异常，请检查货架是否正常";
                    return result;
                }

                StreamReader streamReader = new StreamReader(httpResponse.GetResponseStream());
                respnsetContent = streamReader.ReadToEnd();

                httpResponse.Close();
                streamReader.Close();
                httpWebRequest.Abort();

                //Logger.Default.Info(string.Format("智能货架：请求成功；返回信息：{0}", respnsetContent));
            }
            catch (Exception ex)
            {
                Logger.Default.Info(string.Format("智能货架：请求异常；返回信息：{0}", JsonConvert.SerializeObject(ex)));
                //不捕获指令发出后的异常
                result.Flag = Result.Flags.Failed;
                result.Message = $"智能货架：请求异常；返回信息：{JsonConvert.SerializeObject(ex)}";
                return result;
            }

            JObject jo = JObject.Parse(respnsetContent);
            result.Data = jo;
            return result;
        }


        #region 货架亮灯
        /// <summary>
        /// 全部亮灯
        /// </summary>
        /// <param name="lightParam"></param>
        /// <returns></returns>
        public static async Task<Result<ShelfApiResult>> LightAll(ShelfLightParam lightParam)
        {
            Result<ShelfApiResult> result = new(Result.Flags.Success, $"全部亮灯成功");
            // 准备 POST 请求 body 参数
            var data = new
            {
                shelfNo = lightParam.ShelfNo,
                color = lightParam.LightColor,
                isCover = lightParam.IsCover,
                shelfType = "sensor_shelf"
            };

            string apiUrl = _shelfApiUrl + "/LightAll";
            var jsonString = JsonConvert.SerializeObject(data);

            Result<JObject> result1 = await PostShelfApi(apiUrl, jsonString);
            if (result1.Flag != Result.Flags.Success)
            {
                result.Flag = Result.Flags.Failed;
                result.Message = result1.Message;
                return result;
            }

            result.Data = new ShelfApiResult
            {
                LightType = "Light All",
                IsSuccess = result1.Data["LightAllResult"]["IsSuccess"].ToString(),
                ItemCode = result1.Data["LightAllResult"]["ItemCode"].ToString(),
                ResultValue = result1.Data["LightAllResult"]["ResultValue"].ToString(),
                Type = result1.Data["LightAllResult"]["Type"].ToString(),
            };
            return result;
        }

        /// <summary>
        /// 全部灭灯
        /// </summary>
        /// <param name="lightParam"></param>
        /// <returns></returns>
        public static async Task<Result<ShelfApiResult>> DownAll(ShelfLightParam lightParam)
        {
            Result<ShelfApiResult> result = new(Result.Flags.Success, $"全部灭灯成功");
            // 准备 POST 请求 body 参数
            var data = new
            {
                shelfNo = lightParam.ShelfNo,
                shelfType = "sensor_shelf"
            };

            string apiUrl = _shelfApiUrl + "/DownAll";
            var jsonString = JsonConvert.SerializeObject(data);
            Result<JObject> result1 = await PostShelfApi(apiUrl, jsonString);
            if (result1.Flag != Result.Flags.Success)
            {
                result.Flag = Result.Flags.Failed;
                result.Message = result1.Message;
                return result;
            }
            result.Data = new ShelfApiResult
            {
                LightType = "Down All",
                IsSuccess = result1.Data["DownAllResult"]["IsSuccess"].ToString(),
                ItemCode = result1.Data["DownAllResult"]["ItemCode"].ToString(),
                ResultValue = result1.Data["DownAllResult"]["ResultValue"].ToString(),
                Type = result1.Data["DownAllResult"]["Type"].ToString(),
            };
            return result;
        }

        /// <summary>
        /// 单灯亮
        /// </summary>
        /// <param name="lightParam"></param>
        /// <returns></returns>
        public static async Task<Result<ShelfApiResult>> LightSingle(ShelfLightParam lightParam)
        {
            Result<ShelfApiResult> result = new(Result.Flags.Success, $"单灯亮成功");
            //如果参数传入LocationCode
            var nLocation = await Biz.Db.Queryable<WMS_LOCATION>().Where(t => t.LOCATIONCODE == lightParam.LocationCode).FirstAsync();

            // 准备 POST 请求 body 参数
            var data = new
            {
                shelfNo = lightParam.ShelfNo,
                ledAddr = (nLocation == null) ? lightParam.LedAddr : nLocation.LedAddr.ToString(),
                color = lightParam.LightColor.IsNullOrEmpty() ? _shelfLightColor : lightParam.LightColor,
                isCover = lightParam.IsCover.IsNullOrEmpty() ? "1" : lightParam.IsCover,
                shelfType = "sensor_shelf"
            };

            string apiUrl = _shelfApiUrl + "/LightSingle";
            var jsonString = JsonConvert.SerializeObject(data);

            Result<JObject> result1 = await PostShelfApi(apiUrl, jsonString);
            if (result1.Flag != Result.Flags.Success)
            {
                result.Flag = Result.Flags.Failed;
                result.Message = result1.Message;
                return result;
            }
            result.Data = new ShelfApiResult
            {
                LightType = "Light Single",
                IsSuccess = result1.Data["LightSingleResult"]["IsSuccess"].ToString(),
                ItemCode = result1.Data["LightSingleResult"]["ItemCode"].ToString(),
                ResultValue = result1.Data["LightSingleResult"]["ResultValue"].ToString(),
                Type = result1.Data["LightSingleResult"]["Type"].ToString(),
            };

            return result;
        }

        /// <summary>
        /// 单灯灭
        /// </summary>
        /// <param name="lightParam"></param>
        /// <returns></returns>
        public static async Task<Result<ShelfApiResult>> DownSingle(ShelfLightParam lightParam)
        {
            Result<ShelfApiResult> result = new(Result.Flags.Success, $"单灯灭成功");
            // 准备 POST 请求 body 参数
            var data = new
            {
                shelfNo = lightParam.ShelfNo,
                ledAddr = lightParam.LedAddr,
                shelfType = "sensor_shelf"
            };

            string apiUrl = _shelfApiUrl + "/DownSingle";
            var jsonString = JsonConvert.SerializeObject(data);

            Result<JObject> result1 = await PostShelfApi(apiUrl, jsonString);
            if (result1.Flag != Result.Flags.Success)
            {
                result.Flag = Result.Flags.Failed;
                result.Message = result1.Message;
                return result;
            }
            result.Data = new ShelfApiResult()
            {
                LightType = "Down Single",
                IsSuccess = result1.Data["DownSingleResult"]["IsSuccess"].ToString(),
                ItemCode = result1.Data["DownSingleResult"]["ItemCode"].ToString(),
                ResultValue = result1.Data["DownSingleResult"]["ResultValue"].ToString(),
                Type = result1.Data["DownSingleResult"]["Type"].ToString(),
            };
            return result;
        }

        /// <summary>
        /// 多灯亮
        /// </summary>
        /// <param name="lightParam"></param>
        /// <returns></returns>
        public static async Task<Result<ShelfApiResult>> LightMulti(ShelfLightParam lightParam)
        {
            Result<ShelfApiResult> result = new(Result.Flags.Success, $"多灯亮成功");
            // 库位列表 LedAddrList
            List<Object> ledList = new List<object>();
            foreach (string led_addr in lightParam.LedAddrList)
            {
                //ledList.Add(new { ledAddr = led_addr, uniqueNumber = "" });
                ledList.Add(new { ledAddress = led_addr, uniqueNumber = "" });
            }

            // 货架库位列表
            List<Object> shelfLedAddr = new List<Object>();
            shelfLedAddr.Add(
                new
                {
                    shelfNo = lightParam.ShelfNo,
                    shelfType = "sensor_shelf",
                    ledAddressList = ledList
                }
            );

            // 准备 POST 请求 body 参数
            var data = new
            {
                shelfLedAddressList = shelfLedAddr,
                parameters = new
                {
                    pdaId = "WMS_PDA",
                    orderCode = "WMS_PDA",
                    userItem1 = "",
                    userItem2 = "",
                    userItem3 = "",
                    userItem4 = "",
                    userItem5 = "",
                },
                operateType = 0,
                color = lightParam.LightColor.IsNullOrEmpty() ? _shelfLightColor : lightParam.LightColor,
                isCover = lightParam.IsCover.IsNullOrEmpty() ? "1" : lightParam.IsCover,
            };

            string apiUrl = _shelfApiUrl + "/LightMulti";
            var jsonString = JsonConvert.SerializeObject(data);

            Result<JObject> result1 = await PostShelfApi(apiUrl, jsonString);
            if (result1.Flag != Result.Flags.Success)
            {
                result.Flag = Result.Flags.Failed;
                result.Message = result1.Message;
                return result;
            }
            result.Data = new ShelfApiResult
            {
                LightType = "Light Multi",
                IsSuccess = result1.Data["LightMultiResult"]["IsSuccess"].ToString(),
                ItemCode = result1.Data["LightMultiResult"]["ItemCode"].ToString(),
                ResultValue = result1.Data["LightMultiResult"]["ResultValue"].ToString(),
                Type = result1.Data["LightMultiResult"]["Type"].ToString(),
            };
            return result;
        }

        /// <summary>
        /// 多灯灭
        /// </summary>
        /// <param name="lightParam"></param>
        /// <returns></returns>
        public static async Task<Result<ShelfApiResult>> DownMulti(ShelfLightParam lightParam)
        {
            Result<ShelfApiResult> result = new(Result.Flags.Success, $"多灯灭成功");
            // 库位列表 LedAddrList
            List<Object> ledList = new List<object>();
            foreach (string led_addr in lightParam.LedAddrList)
            {
                //ledList.Add(new { ledAddr = led_addr, uniqueNumber = "" });
                ledList.Add(new { ledAddress = led_addr, uniqueNumber = "" });
            }

            // 货架库位列表
            List<Object> shelfLedAddr = new List<Object>();
            shelfLedAddr.Add(
                new
                {
                    shelfNo = lightParam.ShelfNo,
                    shelfType = "sensor_shelf",
                    ledAddressList = ledList
                }
            );

            // 准备 POST 请求 body 参数
            var data = new
            {
                shelfLedAddressList = shelfLedAddr,
                parameters = new
                {
                    pdaId = "",
                    orderCode = "",
                    userItem1 = "",
                    userItem2 = ""
                },
                operateType = lightParam.OperateType,
                color = lightParam.LightColor,
                isCover = lightParam.IsCover,
            };

            string apiUrl = _shelfApiUrl + "/DownMulti";
            var jsonString = JsonConvert.SerializeObject(data);

            Result<JObject> result1 = await PostShelfApi(apiUrl, jsonString);
            if (result1.Flag != Result.Flags.Success)
            {
                result.Flag = Result.Flags.Failed;
                result.Message = result1.Message;
                return result;
            }
            result.Data = new ShelfApiResult
            {
                LightType = "Down Multi",
                IsSuccess = result1.Data["DownMultiResult"]["IsSuccess"].ToString(),
                ItemCode = result1.Data["DownMultiResult"]["ItemCode"].ToString(),
                ResultValue = result1.Data["DownMultiResult"]["ResultValue"].ToString(),
                Type = result1.Data["DownMultiResult"]["Type"].ToString(),
            };
            return result;
        }

        /// <summary>
        /// 操作货架灯塔
        /// </summary>
        /// <param name="lightParam"></param>
        /// <returns></returns>
        public static async Task<Result<ShelfApiResult>> OperateTowerLight(ShelfLightParam lightParam)
        {
            Result<ShelfApiResult> result = new(Result.Flags.Success, $"多灯灭成功");
            // 准备 POST 请求 body 参数
            var data = new
            {
                shelfNo = lightParam.ShelfNo,
                color = 3,
                operEnum = lightParam.OperEnum,
                shelfType = "sensor_shelf"
            };

            string apiUrl = _shelfApiUrl + "/OperateTowerLight";
            var jsonString = JsonConvert.SerializeObject(data);

            Result<JObject> result1 = await PostShelfApi(apiUrl, jsonString);
            if (result1.Flag != Result.Flags.Success)
            {
                result.Flag = Result.Flags.Failed;
                result.Message = result1.Message;
                return result;
            }
            result.Data = new ShelfApiResult
            {
                LightType = "Operate TowerLight",
                IsSuccess = result1.Data["OperateTowerLightResult"]["IsSuccess"].ToString(),
                ItemCode = result1.Data["OperateTowerLightResult"]["ItemCode"].ToString(),
                ResultValue = result1.Data["OperateTowerLightResult"]["ResultValue"].ToString(),
                Type = result1.Data["OperateTowerLightResult"]["Type"].ToString()
            };
            return result;
        }
        #endregion


    }
}