using Model;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using RestSharp;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Configuration;
using System.Security.Policy;
using System.Text;
using System.Threading.Tasks;
using ResponeData = Model.ResponeData;

namespace BLL
{
    /// <summary>
    /// 集团服务类
    /// </summary>
    public static class ServerService
    {
        /// <summary>
        /// 获取集团token
        /// </summary>
        /// <returns></returns>
        public static Model.TokenItem GetCNCECToken()
        {
            string CNCECPath = SysConstSetService.CNCECPath;
            string baseurl = CNCECPath + "/api/Common/GetToken";
            var client = new RestClient(baseurl);
            client.Timeout = 2000;//获取token设置超时时间为3秒
            var request = new RestRequest(Method.POST);
            ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
            var thisUnit = CommonService.GetIsThisUnit();
            request.AddParameter("UnitName", thisUnit.UnitName);
            request.AddParameter("CollCropCode", thisUnit.CollCropCode);
            //request.AddJsonBody(JsonBody);
            IRestResponse response = client.Execute(request);
            Console.WriteLine(response.Content);
            TokenItem tokenItem = new TokenItem();

            try
            {
                var responeData = JsonConvert.DeserializeObject<Model.ResponeData>(response.Content.ToString());
                if (responeData != null && responeData.code == 1 && string.IsNullOrEmpty(responeData.message))
                {
                    var token = JsonConvert.DeserializeObject<Model.TokenItem>(responeData.data.ToString());
                    tokenItem.Token = token.Token.ToString();
                    tokenItem.ExpiryTime = token.ExpiryTime.ToString();
                    SysConstSetService.SetToken(tokenItem.Token);
                    SysConstSetService.SetTokenExpirationTime(tokenItem.ExpiryTime);
                }

            }
            catch (Exception e)
            {
            }

            return tokenItem;

        }
        /// <summary>
        /// 推送数据至集团（post接口）
        /// </summary>
        /// <param name="JsonBody"></param>
        /// <param name="apiurl"></param>
        /// <returns></returns>
        public static Model.ReturnData PushCNCEC(string JsonBody, string apiurl)
        {
            try
            {
                Model.ReturnData responeData = new Model.ReturnData();
                string CNCECPath = SysConstSetService.CNCECPath;
                //CNCECPath = "http://localhost:7143";
                if (string.IsNullOrEmpty(CNCECPath))
                {
                    responeData.code = 0;
                    responeData.message = "接口地址为空，请配置！";
                    return responeData;

                }
                string baseurl = CNCECPath + apiurl;
                var client = new RestClient(baseurl);
                client.Timeout = -1;
                var request = new RestRequest(Method.POST);
                ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
                var tokenItem = GetToken();
                request.AddHeader("token", tokenItem.Token);
                request.AddJsonBody(JsonBody);
                IRestResponse response = client.Execute(request);
                APICommonService.SaveSysHttpLog("api_Out", baseurl, response.Content);
                var returnData = JsonConvert.DeserializeObject<Model.ResponeData>(response.Content.ToString());
                responeData.code = returnData.code;
                responeData.message = returnData.message;
                return responeData;
            }
            catch (Exception ex)
            {

                throw;
            }
        }
        /// <summary>
        /// 获取token
        /// </summary>
        /// <returns></returns>
        public static Model.TokenItem GetToken()
        {
            Model.TokenItem tokenItem = new Model.TokenItem();
            tokenItem.Token = BLL.SysConstSetService.CNCECToken;
            tokenItem.ExpiryTime = BLL.SysConstSetService.CNCECTTokenExTime;
            if (string.IsNullOrEmpty(tokenItem.Token) || string.IsNullOrEmpty(tokenItem.ExpiryTime))
            {
                //DateTime.Parse(SysConstSetService.CNCECTTokenExTime).AddMinutes(-10) > DateTime.Now
                tokenItem = GetCNCECToken();
            }
            else if (DateTime.Parse(SysConstSetService.CNCECTTokenExTime).AddMinutes(-10) < DateTime.Now)
            {
                tokenItem = GetCNCECToken();

            }
            return tokenItem;
        }
        /// <summary>
        /// 从集团获取数据（Get接口）
        /// </summary>
        /// <param name="apiurl">接口地址</param>
        /// <param name="parameters">parameters参数</param>
        /// <param name="timeout">超时时间</param>
        /// <returns></returns>
        public static Model.ResponeData GerDataFromCncec(string apiurl, Dictionary<string, string> parameters, int? timeout = null)
        {
            Model.ResponeData responeData = new Model.ResponeData();

            try
            {

                string CNCECPath = SysConstSetService.CNCECPath;
                if (string.IsNullOrEmpty(CNCECPath))
                {
                    responeData.code = 0;
                    responeData.message = "接口地址为空，请配置！";
                    return responeData;

                }
                string baseurl = CNCECPath + apiurl;
                var client = new RestClient(baseurl);
                client.Timeout = timeout ?? -1;
                var request = new RestRequest(Method.GET);
                ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
                var tokenItem = GetToken();
                if (tokenItem == null || string.IsNullOrEmpty(tokenItem.Token))
                {
                    responeData.code = 0;
                    responeData.message = "token 不存在！";
                    return responeData;
                }

                request.AddHeader("token", tokenItem.Token);
                if (parameters != null)
                {
                    foreach (var parameter in parameters)
                    {
                        request.AddParameter(parameter.Key, parameter.Value);
                    }
                }

                IRestResponse response = client.Execute(request);
                APICommonService.SaveSysHttpLog("api_Out", baseurl, response.Content);
                var returnData = JsonConvert.DeserializeObject<Model.ResponeData>(response.Content.ToString());
                if (returnData != null)
                {
                    responeData.code = returnData.code;
                    responeData.message = returnData.message;
                    responeData.data = returnData.data;

                }
                else
                {
                    responeData.code = -1;
                    responeData.message = "接口有误";
                }

                return responeData;
            }
            catch (Exception ex)
            {
                responeData.code = 0;
                responeData.message = ex.ToString();
                return responeData;
            }
        }


        /// <summary>
        /// 获取安全合规列表
        /// </summary>
        /// <param name="type">类型（1-法律法规；2-标准规范；3-规章制度；4-管理规定）</param>
        /// <returns></returns>
        public static async Task<List<Model.SafeLawItem>> GetSafeLawListByTypeAsync(string type)
        {
            // 使用 lambda 表达式来调用 getSafeLawListByType
            return await Task.Run(() => GetSafeLawListByType(type));
        }
        /// <summary>
        /// 获取安全合规列表
        /// </summary>
        /// <param name="type">类型（1-法律法规；2-标准规范；3-规章制度；4-管理规定）</param>
        /// <returns></returns>
        public static List<Model.SafeLawItem> GetSafeLawListByType(string type)
        {
            List<SafeLawItem> result = new List<SafeLawItem>();
            string baseurl = "/api/Resources/getSafeLawListByType";
            Dictionary<string, string> dic = new Dictionary<string, string>()
            {
                {"type",type},
                {"pageIndex","0"}

            };
            var returnData = GerDataFromCncec(baseurl, dic, 3000);
            if (returnData != null && returnData.code == 1)
            {
                JObject jt = Newtonsoft.Json.JsonConvert.DeserializeObject<JObject>(returnData.data.ToString());
                var data = jt["getDataList"].ToString();
                result = JsonConvert.DeserializeObject<List<Model.SafeLawItem>>(data);

            }
            return result;
        }
        /// <summary>
        /// 获取公告列表
        /// </summary>
        /// <returns></returns>
        public static List<Model.NoticeOutput> GetNoticeList()
        {
            List<NoticeOutput> result = new List<NoticeOutput>();
            string baseurl = "/api/Notice/getNoticeList";
            Dictionary<string, string> dic = new Dictionary<string, string>()
            {
                {"pageIndex","0"}

            };
            var returnData = GerDataFromCncec(baseurl, dic, 4000);
            if (returnData != null && returnData.code == 1)
            {
                JObject jt = Newtonsoft.Json.JsonConvert.DeserializeObject<JObject>(returnData.data.ToString());
                var data = jt["getDataList"].ToString();
                result = JsonConvert.DeserializeObject<List<Model.NoticeOutput>>(data);

            }
            return result;
        }
        /// <summary>
        /// 获取公告列表
        /// </summary>
        /// <returns></returns>
        public static async Task<List<Model.NoticeOutput>> GetNoticeListAsync()
        {
            return await Task.Run(() => GetNoticeList());
        }
        /// <summary>
        /// 获取新闻列表
        /// </summary>
        /// <returns></returns>
        public static List<Model.NoticeOutput> GetNewsList()
        {
            List<NoticeOutput> result = new List<NoticeOutput>();
            string baseurl = "/api/Notice/getNewsList";
            Dictionary<string, string> dic = new Dictionary<string, string>()
            {
                {"pageIndex","0"}

            };
            var returnData = GerDataFromCncec(baseurl, dic, 3000);
            if (returnData != null && returnData.code == 1)
            {
                JObject jt = Newtonsoft.Json.JsonConvert.DeserializeObject<JObject>(returnData.data.ToString());
                var data = jt["getDataList"].ToString();
                result = JsonConvert.DeserializeObject<List<Model.NoticeOutput>>(data);

            }
            return result;
        }
        /// <summary>
        /// 获取新闻列表
        /// </summary>
        /// <returns></returns>
        public static async Task<List<Model.NoticeOutput>> GetNewsListAsync()
        {
            return await Task.Run(() => GetNewsList());
        }
        /// <summary>
        /// 获取QHSEUrl
        /// </summary>
        /// <returns></returns>
        public static string GetQHSEUrl()
        {
            var result = GerDataFromCncec("/api/Data/GetWebUrl", null, 3000).data?.ToString();
            return result;
        }
    }
}