using ivf_tl_Entity;
using ivf_tl_Entity.DebugEntitys;
using ivf_tl_Entity.DTO;
using ivf_tl_Entity.GlobalEntitys;
using ivf_tl_Entity.GlobalEnums;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Principal;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Documents;
using System.Xml.Linq;

namespace ivf_tl_Services
{
    public class HttpHelper
    {
        private HttpClient client;

        private LogHelper logHelper = null;

        private string token = null;

        private string Account = null;

        private string PassWord = null;

        //����߳�ʱ
        private TimeSpan AsyncTimeout = new TimeSpan(0, 0, 10);

        //��������ʱ
        TimeSpan ServiceTimeout = new TimeSpan(0, 0, 12);

        public HttpHelper(string account, string passWord, LogHelper logHelper)
        {
            // client.DefaultRequestHeaders.Add("token", Token);
            //BaseAddress = new Uri(baseAddress),
            Account = account;
            PassWord = passWord;
            this.logHelper = logHelper;
        }

        public ExUserInfo Init(string baseAddress)
        {
            client = new HttpClient()
            {
                BaseAddress = new Uri(baseAddress),
                Timeout = ServiceTimeout
            };
            client.DefaultRequestHeaders.ExpectContinue = false;
            System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
            return Login();
        }

        private void ExLog(Exception ex, string name)
        {
            logHelper.ExceptionLog(ex, $"HttpHelper.{name}", LogEnum.RunException);
        }

        private void ErrorLog(string message, LogEnum logType)
        {
            logHelper.TLLog($"HttpHelper.{message}", logType);
        }

        public void GetMp4()
        {
            try
            {
                string newFile = @"C:\Users\20552\Desktop\123\1.mp4";
                string url = "http://gateway.aivfo.com:36000/group1/M00/01/26/wKgfWWTDS1OAJAeCAABDxrBoDoo005.mp4?token=token";
                HttpResponseMessage res = client.GetAsync(url).Result;
                using (var fs = File.Create(newFile))
                {
                    var resultStream = res.Content.ReadAsStreamAsync().Result;
                    resultStream.CopyTo(fs);
                    fs.Close();
                }
                string sss = "";
            }
            catch (Exception ex)
            {

            }
        }

        #region ����
        public async Task<int> DownLoadFileAsync(string url, string newFileName)
        {
            string traceId = Guid.NewGuid().ToString("N");
            try
            {
                url = url.Replace("+", "%2B");
                url = url.Replace(",", "%2C");
                if (string.IsNullOrEmpty(GetToken())) return 0;
                var request = new HttpRequestMessage(HttpMethod.Get, url);
                request.Headers.Add("token", token);
                request.Headers.Add("traceId", traceId);
                //CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
                //cancellationTokenSource.CancelAfter(AsyncTimeout);
                var responseMessage = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
                if (responseMessage.StatusCode != HttpStatusCode.OK)
                {
                    ErrorLog($"DownLoadFile���ʷ�����ʧ�ܣ�[url:{url}],[traceId:{traceId}]", LogEnum.RunError);
                    return 0;
                }
                using (var fs = File.Create(newFileName))
                {
                    using (var download = await responseMessage.Content.ReadAsStreamAsync())
                    {
                        var buffer = new byte[10240];
                        int bytesRead;
                        while ((bytesRead = await download.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false)) != 0)
                        {

                            await fs.WriteAsync(buffer, 0, bytesRead).ConfigureAwait(false);
                        }
                    }
                }
                return 1;
            }
            catch (Exception ex)
            {
                ExLog(ex, $"DownLoadFileAsync���ʷ������쳣��[url:{url}],[traceId:{traceId}]");
                return -1;
            }
        }

        public async Task<int> DownLoadFileAsync(string url, string newFileName, string body)
        {
            string traceId = Guid.NewGuid().ToString("N");
            try
            {
                url = url.Replace("+", "%2B");
                url = url.Replace(",", "%2C");
                if (string.IsNullOrEmpty(GetToken())) return 0;

                HttpContent httpContent = new StringContent(body);
                httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
                httpContent.Headers.ContentType.CharSet = "utf-8";

                var request = new HttpRequestMessage(HttpMethod.Get, url) { Content = httpContent };
                request.Headers.Add("token", token);
                request.Headers.Add("traceId", traceId);
                //CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
                //cancellationTokenSource.CancelAfter(AsyncTimeout);
                var responseMessage = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
                if (responseMessage.StatusCode != HttpStatusCode.OK)
                {
                    ErrorLog($"DownLoadFile���ʷ�����ʧ�ܣ�[url:{url}],[traceId:{traceId}]", LogEnum.RunError);
                    return 0;
                }
                using (var fs = File.Create(newFileName))
                {
                    using (var download = await responseMessage.Content.ReadAsStreamAsync())
                    {
                        var buffer = new byte[10240];
                        int bytesRead;
                        while ((bytesRead = await download.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false)) != 0)
                        {

                            await fs.WriteAsync(buffer, 0, bytesRead).ConfigureAwait(false);
                        }
                    }
                }
                return 1;
            }
            catch (Exception ex)
            {
                ExLog(ex, $"DownLoadFileAsync���ʷ������쳣��[url:{url}],[traceId:{traceId}]");
                return -1;
            }
        }
        #endregion

        #region ����ƽ��ӿ�
        public bool StartBalanceApi(int houseSn, string tlSn)
        {
            string funcName = "StartBalanceApi";
            try
            {
                string url = "/api/businessManage/surface/balance/startBalance";
                string body = JsonConvert.SerializeObject(new { houseSn = houseSn, tlSn = tlSn });
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return false;
                HttpResult<object> rs = JsonConvert.DeserializeObject<HttpResult<object>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ��:{resultString}", LogEnum.RunError);
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return false;
            }
        }

        public bool StopBalanceApi(long id)
        {
            string funcName = "StopBalanceApi";
            try
            {
                string url = "/api/businessManage/surface/balance/stopBalance";
                string body = JsonConvert.SerializeObject(new { id = id });
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return false;
                HttpResult<object> rs = JsonConvert.DeserializeObject<HttpResult<object>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ��:{resultString}", LogEnum.RunError);
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return false;
            }
        }
        #endregion

        #region ���������ӿ�
        /// <summary>
        /// ���߹��� - �����б�
        /// </summary>
        /// <param name="tlsn"></param>
        /// <returns></returns>
        public GetHouseStateData GetHouseCultureListApi(string tlsn)
        {
            string funcName = "GetHouseCultureListApi";
            try
            {
                string url = "/api/businessManage/surface/embryoCultureRecord/getHouseCultureList";
                Dictionary<string, string> keyValuePairs = new Dictionary<string, string>();
                keyValuePairs.Add("tlSn", tlsn);
                var resultString = callWebService(url, keyValuePairs);
                if (string.IsNullOrEmpty(resultString)) return new GetHouseStateData();
                HttpResult<GetHouseStateData> rs = JsonConvert.DeserializeObject<HttpResult<GetHouseStateData>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ��:{resultString}", LogEnum.RunError);
                    return new GetHouseStateData();
                }
                if (rs.data != null) return rs.data;
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return new GetHouseStateData();
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return new GetHouseStateData();
            }
        }

        /// <summary>
        /// ��ʼ���� - ���ӻ�����Ϣ
        /// </summary>
        /// <param name="exDish"></param>
        /// <returns></returns>

        public string AddCultureRecordApi(ExDish exDish)
        {
            string funcName = "AddCultureRecordApi";
            try
            {
                string url = "/api/businessManage/surface/embryoCultureRecord/addCultureRecord";
                string body = JsonConvert.SerializeObject(exDish);
                var resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return "����������ʧ��";
                HttpResult rs = JsonConvert.DeserializeObject<HttpResult>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ��:{resultString}", LogEnum.RunError);
                    return rs.message;
                }
                return null;
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return ex.Message;
            }
        }

        /// <summary>
        /// ��������
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public bool EndCultureRecordApi(long id)
        {
            string funcName = "EndCultureRecordApi";
            try
            {
                string url = "/api/businessManage/surface/embryoCultureRecord/endCultureRecord";
                Dictionary<string, string> keyValuePairs = new Dictionary<string, string>();
                keyValuePairs.Add("id", id.ToString());
                string resultString = callWebService(url, keyValuePairs);
                if (string.IsNullOrEmpty(resultString)) return false;
                HttpResult rs = JsonConvert.DeserializeObject<HttpResult>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�ܣ�{resultString}", LogEnum.RunError);
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return false;
            }
        }
        public bool UpdateDishInfoApi(string body)
        {
            string funcName = "UpdateDishInfoApi";
            try
            {
                string url = "/api/businessManage/surface/embryoCultureRecord/updateCultureRecord";
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return false;
                HttpResult rs = JsonConvert.DeserializeObject<HttpResult>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�ܣ�{resultString}", LogEnum.RunError);
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return false;
            }
        }
        #endregion

        #region �豸���ݽӿ�
        /// <summary>
        /// ��ȡͼƬ��Ƶ
        /// </summary>
        /// <param name="tlsn"></param>
        /// <param name="housesn"></param>
        /// <param name="dishId"></param>
        /// <returns></returns>
        public List<GetPicturesByRecordIdData> GetPicturesByRecordIdApi(string tlsn, int housesn, long dishId, List<int> wellList)
        {
            string funcName = "GetPicturesByRecordIdApi";
            try
            {
                string url = "/api/businessManage/surface/resource/getPicturesByRecordId";
                string body = JsonConvert.SerializeObject(new { tlSn = tlsn, houseSn = housesn, id = dishId, wellSnList = wellList });
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return new List<GetPicturesByRecordIdData>();
                HttpResult<List<GetPicturesByRecordIdData>> rs = JsonConvert.DeserializeObject<HttpResult<List<GetPicturesByRecordIdData>>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�� {resultString}", LogEnum.RunError);
                    return new List<GetPicturesByRecordIdData>();
                }
                if (rs.data == null)
                {
                    ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                    return new List<GetPicturesByRecordIdData>();
                }
                foreach (var item in rs.data)
                {
                    if (item.videoPictures == null) item.videoPictures = new List<PictureEntity>();
                    if (item.videos == null) item.videos = new List<VideoEntity>();
                    if (item.videoPictures.Any()) item.videoPictures = item.videoPictures.OrderBy(x => x.developTime).ToList();
                    if (item.videos.Any()) item.videos = item.videos.OrderBy(x => x.pictureLayer).ToList();
                }
                return rs.data;
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return new List<GetPicturesByRecordIdData>();
            }
        }

        public List<DishPicAndVideo> GetRecordDetailApi(string tlsn, int housesn, long dishId, List<int> wellList)
        {
            string funcName = "GetRecordDetailApi";
            try
            {
                string url = "/api/businessManage/surface/resource/getRecordDetail";
                string body = JsonConvert.SerializeObject(new { tlSn = tlsn, houseSn = housesn, id = dishId, wellSnList = wellList });

                //ErrorLog($"/api/businessManage/surface/resource/getRecordDetail�ӿڲ�����{body}", LogEnum.RunRecord);

                string resultString = callWebService(url, body);

                //ErrorLog($"/api/businessManage/surface/resource/getRecordDetail�ӿڷ��أ�{resultString}", LogEnum.RunRecord);

                if (string.IsNullOrEmpty(resultString)) return new List<DishPicAndVideo>();
                HttpResult<List<DishPicAndVideo>> rs = JsonConvert.DeserializeObject<HttpResult<List<DishPicAndVideo>>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�� {resultString}", LogEnum.RunError);
                    return new List<DishPicAndVideo>();
                }
                if (rs.data != null) return rs.data;
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return new List<DishPicAndVideo>();
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return new List<DishPicAndVideo>();
            }
        }

        /// <summary>
        /// ��ȡָ��wellָ��ͼ���ͼƬ
        /// </summary>
        /// <param name="tlsn"></param>
        /// <param name="housesn"></param>
        /// <param name="dishId"></param>
        /// <param name="wellList"></param>
        /// <param name="layerList"></param>
        public List<SwitchVideoPictureLayersData> SwitchVideoPictureLayersApi(string tlsn, int housesn, long dishId, List<int> wellList, List<int> layerList)
        {
            string funcName = "SwitchVideoPictureLayersApi";
            try
            {
                string url = "/api/businessManage/surface/resource/switchVideoPictureLayers";
                string body = JsonConvert.SerializeObject(new { tlSn = tlsn, houseSn = housesn, id = dishId, wellSnList = wellList, pictureLayer = layerList });
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return new List<SwitchVideoPictureLayersData>();
                HttpResult<List<SwitchVideoPictureLayersData>> rs = JsonConvert.DeserializeObject<HttpResult<List<SwitchVideoPictureLayersData>>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�� {resultString}", LogEnum.RunError);
                    return new List<SwitchVideoPictureLayersData>();
                }
                if (rs.data != null) return rs.data;
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return new List<SwitchVideoPictureLayersData>();
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return new List<SwitchVideoPictureLayersData>();
            }
        }
        #endregion

        #region
        public List<ButtonEntity> GetQuickButtonsApi()
        {
            string funcName = "GetQuickButtonsApi";
            try
            {
                string url = "/api/businessManage/surface/photoSearchButton/getButtons";
                string body = JsonConvert.SerializeObject(new { types = new List<string> { "QUICK_BUTTON" } });
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return new List<ButtonEntity>();
                HttpResult<List<GetButtonsResult>> rs = JsonConvert.DeserializeObject<HttpResult<List<GetButtonsResult>>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ��  {resultString}", LogEnum.RunError);
                    return new List<ButtonEntity>();
                }
                if (rs.data.Any() && rs.data.First().button != null && rs.data.First().button.Any())
                {
                    return rs.data.First().button;
                }
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return new List<ButtonEntity>();
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return new List<ButtonEntity>();
            }
        }

        public List<GetButtonsResult> GetTimeButtonsApi()
        {
            string funcName = "GetTimeButtonsApi";
            try
            {
                string url = "/api/businessManage/surface/photoSearchButton/getButtons";
                string body = JsonConvert.SerializeObject(new { types = new List<string> { "COMMON_BUTTON", "KEY_BUTTON " } });
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return new List<GetButtonsResult>();
                HttpResult<List<GetButtonsResult>> rs = JsonConvert.DeserializeObject<HttpResult<List<GetButtonsResult>>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ��  {resultString}", LogEnum.RunError);
                    return new List<GetButtonsResult>();
                }
                if (rs.data != null && rs.data.Any()) return rs.data;
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return new List<GetButtonsResult>();
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return new List<GetButtonsResult>();
            }
        }
        #endregion

        #region �������� TL��λ��ͨѶ�����ӿ�

        /// <summary>
        /// ��ȡ��������
        /// </summary>
        public SettingDataApiData GetSettingDataApi(TLInitData tLInitData)
        {
            string funcName = "GetSettingDataApi";
            try
            {
                string url = "/api/tl/control/time-lapse-equipment/setting/data";
                string body = JsonConvert.SerializeObject(tLInitData);
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return null;
                HttpResult<SettingDataApiData> rs = JsonConvert.DeserializeObject<HttpResult<SettingDataApiData>>(resultString);
                if (!rs.success)
                {
                    logHelper.TLLog($"{funcName}�ӿڷ���ʧ�ܣ�{resultString}", LogEnum.RunError);
                    return null;
                }
                if (rs.data != null) return rs.data;
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return null;
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return null;
            }
        }

        #endregion

        #region ��λ����������  TL����������ݽӿ�
        /// <summary>
        /// ��ȡָ��tlSn��ϵͳ����
        /// </summary>
        /// <param name="tlsn"></param>
        /// <returns></returns>
        public TLSettingModel SettingSystemApi(string tlsn)
        {
            string funcName = "SettingSystemApi";
            try
            {
                string url = "/api/tl/control/setting/system";
                Dictionary<string, string> keyValuePairs = new Dictionary<string, string>();
                keyValuePairs.Add("tlSn", tlsn);
                string resultString = callWebService(url, keyValuePairs);
                if (string.IsNullOrEmpty(resultString)) return new TLSettingModel();
                HttpResult<TLSettingModel> rs = JsonConvert.DeserializeObject<HttpResult<TLSettingModel>>(resultString);
                if (!rs.success)
                {
                    logHelper.TLLog($"{funcName}�ӿڷ���ʧ�ܣ�{resultString}", LogEnum.RunError);
                    return new TLSettingModel();
                }
                if (rs.data != null) return rs.data;
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return new TLSettingModel();
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return new TLSettingModel();
            }
        }

        /// <summary>
        /// ����ָ��tlSnϵͳ����
        /// </summary>
        /// <param name="tLSettingModel"></param>
        /// <returns></returns>
        public string SystemUpdateApi(TLSettingModel tLSettingModel)
        {
            string funcName = "SystemUpdateApi";
            try
            {
                string url = "/api/tl/control/setting/system/update";
                string body = JsonConvert.SerializeObject(tLSettingModel);
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return "���������ؿ�";
                HttpResult rs = JsonConvert.DeserializeObject<HttpResult>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�ܣ�{resultString}", LogEnum.RunError);
                    return rs.message;
                }
                return null;
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return ex.Message;
            }
        }

        public VersionEntity GetVersionBySnApi(string tlsn)
        {
            string funcName = "GetVersionBySnApi";
            try
            {
                string url = "/api/tl/control/tlInfo/getVersionBySn";
                Dictionary<string, string> keyValuePairs = new Dictionary<string, string>();
                keyValuePairs.Add("tlSn", tlsn);
                string resultString = callWebService(url, keyValuePairs);
                if (string.IsNullOrEmpty(resultString)) return new VersionEntity();
                var rs = JsonConvert.DeserializeObject<HttpResult<VersionEntity>>(resultString);
                if (!rs.success)
                {
                    logHelper.TLLog($"{funcName}�ӿڷ���ʧ�ܣ�{resultString}", LogEnum.RunError);
                    return new VersionEntity();
                }
                if (rs.data != null) return rs.data;
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return new VersionEntity();
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return new VersionEntity();
            }
        }

        /// <summary>
        /// ��ȡָ��tlSn�IJ�������
        /// </summary>
        /// <param name="tlSn"></param>
        /// <returns></returns>
        public List<HouseInfo> GetSettingHouseApi(string tlSn)
        {
            string funcName = "GetSettingHouseApi";
            try
            {
                string url = "/api/tl/control/setting/house";
                string body = JsonConvert.SerializeObject(new { tlSn = tlSn, size = 100, current = 1 });
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return new List<HouseInfo>();
                HttpResult<SettingHouseData> rs = JsonConvert.DeserializeObject<HttpResult<SettingHouseData>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�ܣ�{resultString}", LogEnum.RunError);
                    return new List<HouseInfo>();
                }
                if (rs.data != null && rs.data.records != null) return rs.data.records;
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return new List<HouseInfo>();
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return new List<HouseInfo>();
            }
        }

        /// <summary>
        /// ����ָ��tlSn��������
        /// </summary>
        /// <param name="houseList"></param>
        public bool HouseUpdateApi(ObservableCollection<HouseInfo> houseList)
        {
            string funcName = "HouseUpdateApi";
            try
            {
                string url = "/api/tl/control/setting/house/update";
                List<object> list = new List<object>();
                foreach (var item in houseList)
                {
                    list.Add(new
                    {
                        id = item.id,
                        openCcd = item.openCcd,
                        openPort = item.openPort,
                    });
                }
                string body = JsonConvert.SerializeObject(list);
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return false;
                HttpResult rs = JsonConvert.DeserializeObject<HttpResult>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�ܣ�{resultString}", LogEnum.RunError);
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return false;
            }
        }

        /// <summary>
        /// ��ȡָ��tlSn��tlͨ������
        /// </summary>
        /// <param name="tlsn"></param>
        public TLSettingCommon SettingCommonApi(string tlsn)
        {
            string funcName = "SettingCommonApi";
            try
            {
                string url = "/api/tl/control/setting/common";
                Dictionary<string, string> body = new Dictionary<string, string>();
                body.Add("tlSn", tlsn);
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return new TLSettingCommon();
                HttpResult<TLSettingCommon> rs = JsonConvert.DeserializeObject<HttpResult<TLSettingCommon>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�ܣ�{resultString}", LogEnum.RunError);
                    return new TLSettingCommon();
                }
                if (rs.data != null) return rs.data;
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return new TLSettingCommon();
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return new TLSettingCommon();
            }
        }

        /// <summary>
        /// ����ָ��tlSn��tlͨ������
        /// </summary>
        /// <param name="tLSettingCommon"></param>
        /// <returns></returns>
        public bool CommonUpdateApi(TLSettingCommon tLSettingCommon)
        {
            string funcName = "CommonUpdateApi";
            try
            {
                string url = "/api/tl/control/setting/common/update";
                string body = JsonConvert.SerializeObject(tLSettingCommon);
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return false;
                HttpResult rs = JsonConvert.DeserializeObject<HttpResult>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�ܣ�{resultString}", LogEnum.RunError);
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return false;
            }
        }

        /// <summary>
        /// ���²��ҵ��Ե�������Ϣ
        /// </summary>
        /// <param name="body"></param>
        /// <returns></returns>
        public bool HouseDebuggingApi(string body)
        {
            string funcName = "HouseDebuggingApi";
            try
            {
                string url = "/api/tl/control/setting/house/debugging";
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return false;
                HttpResult rs = JsonConvert.DeserializeObject<HttpResult>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�ܣ�{resultString}", LogEnum.RunError);
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return false;
            }
        }

        /// <summary>
        /// ����well��λ����Ϣ
        /// </summary>
        /// <param name="body"></param>
        /// <returns></returns>
        public bool WellUpdateApi(string body)
        {
            string funcName = "WellUpdateApi";
            try
            {
                string url = "/api/tl/control/setting/house/well/update";
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return false;
                HttpResult rs = JsonConvert.DeserializeObject<HttpResult>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�ܣ�{resultString}", LogEnum.RunError);
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return false;
            }
        }

        /// <summary>
        /// ��ȡ�Խ���������
        /// </summary>
        /// <param name="tlsn"></param>
        public List<AutoFocusHouseInfo> FocusSettingApi(string tlsn)
        {
            string funcName = "FocusSettingApi";
            try
            {
                string url = "/api/tl/control/setting/house/focus/setting";
                Dictionary<string, string> body = new Dictionary<string, string>();
                body.Add("tlSn", tlsn);
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return new List<AutoFocusHouseInfo>();
                HttpResult<List<AutoFocusHouseInfo>> rs = JsonConvert.DeserializeObject<HttpResult<List<AutoFocusHouseInfo>>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�ܣ�{resultString}", LogEnum.RunError);
                    return new List<AutoFocusHouseInfo>();
                }
                if (rs.data != null) return rs.data;
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return new List<AutoFocusHouseInfo>();
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return new List<AutoFocusHouseInfo>();
            }
        }

        /// <summary>
        /// �Խ����������Խ�
        /// </summary>
        /// <param name="tlsn"></param>
        public bool HouseImmediatelyAPi(List<AutoFocusHouseInfoRequest> list)
        {
            string funcName = "HouseImmediatelyAPi";
            try
            {
                string url = "/api/tl/control/setting/house/immediately";
                string body = JsonConvert.SerializeObject(list);
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return false;
                HttpResult rs = JsonConvert.DeserializeObject<HttpResult>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�ܣ�{resultString}", LogEnum.RunError);
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return false;
            }
        }

        /// <summary>
        /// ����ָ��tlSn�ƹ�ǿ���Լ�����ƿ��������ʱ��
        /// </summary>
        /// <returns></returns>
        public bool LightsUpdateApi(string _tlsn, int _dayLighting, int _inletValveOpeningTime)
        {
            string funcName = "LightsUpdateApi";
            try
            {
                string url = "/api/tl/control/setting/lights/update";
                string body = JsonConvert.SerializeObject(new
                {
                    dayLighting = _dayLighting,
                    inletValveOpeningTime = _inletValveOpeningTime,
                    tlSn = _tlsn,
                });
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return false;
                HttpResult rs = JsonConvert.DeserializeObject<HttpResult>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�ܣ�{resultString}", LogEnum.RunError);
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return false;
            }
        }

        /// <summary>
        /// ��ȡTL��ص�ʱ��
        /// </summary>
        /// <param name="tlsn"></param>
        public TlInfoTimeData TlInfoTimeApi(string tlsn)
        {
            string funcName = "TlInfoTimeApi";
            try
            {
                string url = "/api/tl/control/tlInfo/time";
                Dictionary<string, string> body = new Dictionary<string, string>();
                body.Add("tlSn", tlsn);
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return new TlInfoTimeData();
                HttpResult<TlInfoTimeData> rs = JsonConvert.DeserializeObject<HttpResult<TlInfoTimeData>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�� {resultString}", LogEnum.RunError);
                    return new TlInfoTimeData();
                }
                if (rs.data != null) return rs.data;
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return new TlInfoTimeData();
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return new TlInfoTimeData();
            }
        }
        #endregion


        /// <summary>
        /// �����ֵ�Type��ѯ - �������ڵ�
        /// </summary>
        /// <param name="queryType"></param>
        public List<FertilizationTypeEntity> QueryDictionaryByTypeApi(string queryType)
        {
            string funcName = "QueryDictionaryByTypeApi";
            try
            {
                string url = "/api/businessManage/surface/dictionary/queryDictionaryByType";
                string resultString = callWebService(url, JsonConvert.SerializeObject(new { type = queryType }));
                if (string.IsNullOrEmpty(resultString)) return new List<FertilizationTypeEntity>();
                HttpResult<List<FertilizationTypeEntity>> rs = JsonConvert.DeserializeObject<HttpResult<List<FertilizationTypeEntity>>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�� {resultString}", LogEnum.RunError);
                    return new List<FertilizationTypeEntity>();
                }
                if (rs.data != null) return rs.data;
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return new List<FertilizationTypeEntity>();
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return new List<FertilizationTypeEntity>();
            }
        }

        public string GetImageUrlApi(string tlSn, int houseSn, long id, int layer, int developTime)
        {
            string funcName = "GetImageUrlApi";
            try
            {
                string url = "/api/businessManage/surface/resource/switchVideoLayerByPicture";
                string resultString = callWebService(url, JsonConvert.SerializeObject(new { tlSn, houseSn, id, layer, developTime }));
                if (string.IsNullOrEmpty(resultString)) return null;
                var rs = JsonConvert.DeserializeObject<HttpResult<string>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�� {resultString}", LogEnum.RunError);
                    return null;
                }
                return rs.data;
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return null;
            }
        }

        public List<DetailPic> GetVideoTimeLineApi(string tlSn, int houseSn, long id, int layer)
        {
            string funcName = "GetVideoTimeLineApi";
            try
            {
                string url = "/api/businessManage/surface/resource/getVideoTimeLine";
                string resultString = callWebService(url, JsonConvert.SerializeObject(new { tlSn, houseSn, id, layer }));
                if (string.IsNullOrEmpty(resultString)) return null;
                var rs = JsonConvert.DeserializeObject<HttpResult<List<DetailPic>>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�� {resultString}", LogEnum.RunError);
                    return null;
                }
                if (rs.data != null && rs.data.Any()) return rs.data;
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return new List<DetailPic>();
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return null;
            }
        }

        public HouseChartEntity GetHouseEnvironmentListApi(string tlSn, int houseSn, string startTime, string endTime)
        {
            string funcName = "GetHouseEnvironmentListApi";
            try
            {
                string url = "/api/tl/control/houseCollect/getHouseEnvironmentList";
                string resultString = callWebService(url, JsonConvert.SerializeObject(new { tlSn, houseSn, startTime, endTime }));
                if (string.IsNullOrEmpty(resultString)) return new HouseChartEntity();
                var rs = JsonConvert.DeserializeObject<HttpResult<HouseChartEntity>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�� {resultString}", LogEnum.RunError);
                    return null;
                }
                if (rs.data != null) return rs.data;
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return new HouseChartEntity();
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return new HouseChartEntity();
            }
        }

        public bool MarkEmbryoDestinationApi(long id, int state)
        {
            string funcName = "MarkEmbryoDestinationApi";
            try
            {
                string url = "/api/businessManage/surface/embryoMark/markEmbryoDestination";
                string resultString = callWebService(url, JsonConvert.SerializeObject(new { id, state }));
                if (string.IsNullOrEmpty(resultString)) return false;
                var rs = JsonConvert.DeserializeObject<HttpResult>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�� {resultString}", LogEnum.RunError);
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return false;
            }
        }

        public DishRecordResult SearchDishRecordApi(SearchDishRecordResponse searchDishRecord)
        {
            string funcName = "SearchDishRecordApi";
            try
            {
                string url = "/api/businessManage/surface/embryoCultureRecord/getEmbryoCultureRecord";
                string body = JsonConvert.SerializeObject(searchDishRecord, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return new DishRecordResult() { IsSuccess = false };
                var rs = JsonConvert.DeserializeObject<HttpResult<DishRecordResult>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�� {resultString}", LogEnum.RunError);
                    return new DishRecordResult() { IsSuccess = false };
                }
                if (rs.data != null) return rs.data;
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return new DishRecordResult();
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return new DishRecordResult() { IsSuccess = false };
            }
        }

        public DishRecordCountResult SearchDishRecordCountApi(SearchDishRecordResponse searchDishRecord)
        {
            string funcName = "SearchDishRecordCountApi";
            try
            {
                string url = "/api/businessManage/surface/embryoCultureRecord/getEmbryoCultureRecordNum";
                string body = JsonConvert.SerializeObject(searchDishRecord, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });

                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return new DishRecordCountResult();

                var rs = JsonConvert.DeserializeObject<HttpResult<DishRecordCountResult>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�� {resultString}", LogEnum.RunError);
                    return new DishRecordCountResult();
                }
                if (rs.data != null) return rs.data;
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return new DishRecordCountResult();
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return new DishRecordCountResult();
            }
        }

        public DishRecordCountResult SearchAlarmHistoryNumApi(SearchAlarmResponse searchAlarm)
        {
            string funcName = "SearchAlarmHistoryNumApi";
            try
            {
                string url = "/api/tl/control/alarm/getAlarmNum";
                string body = JsonConvert.SerializeObject(searchAlarm, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return new DishRecordCountResult();
                var rs = JsonConvert.DeserializeObject<HttpResult<DishRecordCountResult>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�� {resultString}", LogEnum.RunError);
                    return new DishRecordCountResult();
                }
                if (rs.data != null) return rs.data;
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return new DishRecordCountResult();
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return new DishRecordCountResult();
            }
        }

        public AlarmHistoryResult SearchAlarmHistoryApi(SearchAlarmResponse searchAlarm)
        {
            string funcName = "SearchAlarmHistoryApi";
            try
            {
                string url = "/api/tl/control/alarm/getAlarm";
                string body = JsonConvert.SerializeObject(searchAlarm, new JsonSerializerSettings { NullValueHandling = NullValueHandling.Ignore });

                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return new AlarmHistoryResult() { IsSuccess = false };

                var rs = JsonConvert.DeserializeObject<HttpResult<AlarmHistoryResult>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�� {resultString}", LogEnum.RunError);
                    return new AlarmHistoryResult() { IsSuccess = false };
                }
                if (rs.data != null) return rs.data;
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return new AlarmHistoryResult();
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return new AlarmHistoryResult() { IsSuccess = false };
            }
        }

        public List<PictureView> GetPictureViewApi(string tlSn, int houseSn, long embryoId, int pictureLayer)
        {
            string funcName = "GetPictureViewApi";
            try
            {
                string url = "/api/businessManage/surface/resource/getPictures";
                string body = JsonConvert.SerializeObject(new { tlSn, houseSn, embryoId, pictureLayer });
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return new List<PictureView>();
                var rs = JsonConvert.DeserializeObject<HttpResult<List<PictureView>>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}����������ʧ�� {resultString}", LogEnum.RunError);
                    return new List<PictureView>();
                }
                if (rs.data != null && rs.data.Any()) return rs.data;
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return new List<PictureView>();
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return new List<PictureView>();
            }
        }

        public List<PictureView> GetSourcePictureViewApi(string tlSn, int houseSn, long embryoId, int pictureLayer)
        {
            string funcName = "GetSourcePictureViewApi";
            try
            {
                string url = "/api/businessManage/surface/resource/getSourcePictures";
                string body = JsonConvert.SerializeObject(new { tlSn, houseSn, embryoId, pictureLayer });
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return new List<PictureView>();
                var rs = JsonConvert.DeserializeObject<HttpResult<List<PictureView>>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}����������ʧ�� {resultString}", LogEnum.RunError);
                    return new List<PictureView>();
                }
                if (rs.data != null && rs.data.Any()) return rs.data;
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return new List<PictureView>();
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return new List<PictureView>();
            }
        }

        public ExDish GetExdishByIdApi(long id)
        {
            string funcName = "GetExdishByIdApi";
            try
            {
                string url = "/api/businessManage/pc/embryoCultureRecord/getCultureRecordById";
                var body = new Dictionary<string, string>() { { "id", id.ToString() } };
                string resultString = callWebService(url, body);
                if (string.IsNullOrEmpty(resultString)) return null;
                var rs = JsonConvert.DeserializeObject<HttpResult<ExDish>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}����������ʧ�� {resultString}", LogEnum.RunError);
                    return null;
                }
                if (rs.data != null) return rs.data;
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return null;
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return null;
            }
        }

        public bool MuteAlarmApi(long id, int mute)
        {
            string funcName = "MuteAlarmApi";
            try
            {
                string url = "/api/tl/control/alarm/muteAlarm";
                string resultString = callWebService(url, JsonConvert.SerializeObject(new { id, mute }));
                if (string.IsNullOrEmpty(resultString)) return false;
                var rs = JsonConvert.DeserializeObject<HttpResult>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}����������ʧ�� {resultString}", LogEnum.RunError);
                    return false;
                }
                return true;
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return false;
            }
        }

        public List<HouseCropAlarmResult> GetHouseCropAlarmApi(HouseCropAlarmResponse houseCropAlarmResponse)
        {
            string funcName = "GetHouseCropAlarmApi";
            try
            {
                string url = "/api/tl/control/alarm/getHouseCropAlarm";
                string body = JsonConvert.SerializeObject(houseCropAlarmResponse);
                string resultString = callWebService(url, body);


                if (string.IsNullOrEmpty(resultString)) return new List<HouseCropAlarmResult>();

                HttpResult<List<HouseCropAlarmResult>> rs = JsonConvert.DeserializeObject<HttpResult<List<HouseCropAlarmResult>>>(resultString);

                if (!rs.success)
                {
                    ErrorLog($"{funcName}�ӿڷ���ʧ�� {resultString}", LogEnum.RunError);
                    return new List<HouseCropAlarmResult>();
                }

                if (rs.data != null && rs.data.Any()) return rs.data;
                //ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                return new List<HouseCropAlarmResult>();
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                return new List<HouseCropAlarmResult>();
            }
        }

        #region ��������ʵ��
        public ExUserInfo Login()
        {
            string funcName = "Login";
            try
            {
                string resultString = callWebServiceNoToken("/api/gateway/auth/login", JsonConvert.SerializeObject(new { account = Account, password = PassWord }));
                if (string.IsNullOrEmpty(resultString)) return null;
                var rs = JsonConvert.DeserializeObject<HttpResult<LoginData>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}����������ʧ�ܣ�{resultString}", LogEnum.RunError);
                    token = null;
                    return null;
                }
                if (rs.data != null)
                {
                    token = rs.data.token;
                    return rs.data.userInfo;
                }
                ErrorLog($"{funcName}�ӿڷ��سɹ����������� {resultString}", LogEnum.RunError);
                token = null;
                return null;
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                token = null;
                return null;
            }
        }

        public string GetToken()
        {
            string funcName = "GetToken";
            try
            {
                if (!string.IsNullOrEmpty(token)) return token;
                string resultString = callWebServiceNoToken("/api/gateway/auth/login", JsonConvert.SerializeObject(new { account = Account, password = PassWord }));
                if (string.IsNullOrEmpty(resultString)) return null;
                var rs = JsonConvert.DeserializeObject<HttpResult<LoginData>>(resultString);
                if (!rs.success)
                {
                    ErrorLog($"{funcName}����������ʧ�ܣ�{resultString}", LogEnum.RunError);
                    token = null;
                    return null;
                }
                if (rs.data != null)
                {
                    token = rs.data.token;
                    return token;
                }
                ErrorLog($"{funcName}���سɹ����������� {resultString}", LogEnum.RunError);
                token = null;
                return null;
            }
            catch (Exception ex)
            {
                ExLog(ex, funcName);
                token = null;
                return null;
            }
        }

        public string callWebService(string url)
        {
            try
            {
                if (string.IsNullOrEmpty(GetToken())) return null;
                using var requestNew = new HttpRequestMessage(HttpMethod.Post, url);
                requestNew.Headers.Add("token", token);
                return HttpClientSendAsync(requestNew, url).ConfigureAwait(false).GetAwaiter().GetResult();
            }
            catch (Exception ex)
            {
                logHelper.ExceptionLog(ex, $"���ʷ������쳣��[url:{url}]", LogEnum.RunException);
                return null;
            }
        }

        public string callWebService(string url, string body)
        {
            try
            {
                if (string.IsNullOrEmpty(GetToken())) return null;
                using var requestNew = new HttpRequestMessage(HttpMethod.Post, url);
                using HttpContent httpContent1 = new StringContent(body, Encoding.UTF8, "application/json");
                requestNew.Content = httpContent1;
                requestNew.Headers.Add("token", token);
                return HttpClientSendAsync(requestNew, url).ConfigureAwait(false).GetAwaiter().GetResult();
            }
            catch (Exception ex)
            {
                logHelper.ExceptionLog(ex, $"���ʷ������쳣��[url:{url}],body��{body}", LogEnum.RunException);
                return null;
            }
        }

        public string callWebService(string url, Dictionary<string, string> body)
        {
            try
            {
                if (string.IsNullOrEmpty(GetToken())) return null;
                using var requestNew = new HttpRequestMessage(HttpMethod.Post, url);
                using HttpContent httpContent1 = new FormUrlEncodedContent(body);
                requestNew.Content = httpContent1;
                requestNew.Headers.Add("token", token);
                return HttpClientSendAsync(requestNew, url).ConfigureAwait(false).GetAwaiter().GetResult();
            }
            catch (Exception ex)
            {
                logHelper.ExceptionLog(ex, $"���ʷ������쳣��[url:{url}],body��{JsonConvert.SerializeObject(body)}", LogEnum.RunException);
                return null;
            }
        }

        public string callWebServiceNoToken(string url, string body)
        {
            try
            {
                using var requestNew = new HttpRequestMessage(HttpMethod.Post, url);
                using HttpContent httpContent1 = new StringContent(body, Encoding.UTF8, "application/json");
                requestNew.Content = httpContent1;
                return HttpClientSendAsync(requestNew, url).ConfigureAwait(false).GetAwaiter().GetResult();
            }
            catch (Exception ex)
            {
                logHelper.ExceptionLog(ex, $"���ʷ������쳣��[url:{url}],body��{body}", LogEnum.RunException);
                return null;
            }
        }


        public async Task<string> HttpClientSendAsync(HttpRequestMessage request, string url)
        {
            // M8-P3b：HTTP 边界统一埋点 + traceId 透传给 Java 后端（实现 C#→Java 链路串联）。
            // traceId 取操作日志上下文（无则新建），写入请求 header "traceId"（与 Java 网关读取对齐，见 §9 待对齐点）。
            string traceId = Aivfo.OperationLog.OperationLogContext.TraceId
                             ?? Aivfo.OperationLog.OperationLogContext.NewTraceId();
            string result;
            var sw = System.Diagnostics.Stopwatch.StartNew();
            using var cts = new CancellationTokenSource(AsyncTimeout);
            try
            {
                request.Headers.Add("traceId", traceId);

                using var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cts.Token).ConfigureAwait(false);

                if (!response.IsSuccessStatusCode)
                {
                    logHelper.TLLog($"HttpClientSendAsync���ʷ�����ʧ�� [url:{url}],[TraceID:{traceId}][code:{response.StatusCode}]", LogEnum.RunError);
                    sw.Stop();
                    SafeOpLog(url, traceId, sw.ElapsedMilliseconds, "失败", $"HTTP {(int)response.StatusCode}", null);
                    return null;
                }
                result = response.Content.ReadAsStringAsync().ConfigureAwait(false).GetAwaiter().GetResult();
                sw.Stop();
                SafeOpLog(url, traceId, sw.ElapsedMilliseconds, "成功", null, result);
                return result;
            }
            catch (TaskCanceledException ex) when (cts.IsCancellationRequested)
            {
                logHelper.TLLog($"HttpClientSendAsync����ʱ [url:{url}],[TraceID:{traceId}]", LogEnum.RunError);
                sw.Stop();
                SafeOpLog(url, traceId, sw.ElapsedMilliseconds, "失败", "超时", null);
                return null;
            }
            catch (HttpRequestException ex)
            {
                logHelper.ExceptionLog(ex, $"HttpClientSendAsync�����쳣 [url:{url}],[TraceID:{traceId}]", LogEnum.RunException);
                sw.Stop();
                SafeOpLog(url, traceId, sw.ElapsedMilliseconds, "失败", ex.GetType().Name + ": " + ex.Message, null);
                return null;
            }
            catch (Exception ex)
            {
                logHelper.ExceptionLog(ex, $"HttpClientSendAsync���ʷ������쳣��[url:{url}],[traceId:{traceId}],", LogEnum.RunException);
                sw.Stop();
                SafeOpLog(url, traceId, sw.ElapsedMilliseconds, "失败", ex.GetType().Name + ": " + ex.Message, null);
                return null;
            }
        }

        /// <summary>
        /// M8-P3b：HTTP 边界操作日志（module="HTTP"，operation=接口路径）。全 try 兜底，绝不抛。
        /// output 截断防止过大；result/error 透传调用结果。traceId 显式传入与请求 header 一致。
        /// </summary>
        private void SafeOpLog(string url, string traceId, long elapsedMs, string result, string error, string output)
        {
            try
            {
                string outBrief = output;
                if (!string.IsNullOrEmpty(outBrief) && outBrief.Length > 2000)
                    outBrief = outBrief.Substring(0, 2000) + "...(truncated)";
                // 进入 scope 让本次 traceId 与请求 header 完全一致。
                using (Aivfo.OperationLog.OperationLogContext.BeginScope(traceId))
                {
                    Aivfo.OperationLog.OperationLogger.Log(
                        module: "HTTP",
                        operation: url,
                        output: outBrief,
                        result: result,
                        error: error,
                        elapsedMs: elapsedMs);
                }
            }
            catch { /* 兜底：记日志失败不影响 HTTP 业务 */ }
        }

        public async Task<string> HttpClientSendAsyncStream(HttpRequestMessage request, string url)
        {
            string result = string.Empty;
            // M8-P3b：traceId 取操作日志上下文（无则新建），透传 Java 后端。
            string traceId = Aivfo.OperationLog.OperationLogContext.TraceId
                             ?? Aivfo.OperationLog.OperationLogContext.NewTraceId();
            using var cts = new CancellationTokenSource(AsyncTimeout);
            try
            {
                request.Headers.Add("traceId", traceId);

                using var response = await client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cts.Token).ConfigureAwait(false);

                if (!response.IsSuccessStatusCode)
                {
                    logHelper.TLLog($"HttpClientSendAsyncStream���ʷ�����ʧ�� [url:{url}],[TraceID:{traceId}][code:{response.StatusCode}]", LogEnum.RunError);
                    return null;
                }
                var buffer = new char[4096];
                int bytesRead;
                var StringBuilderResult = new StringBuilder();
                using (var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false))
                {
                    using (var reader = new StreamReader(stream, Encoding.UTF8))
                    {
                        while ((bytesRead = await reader.ReadAsync(buffer).ConfigureAwait(false)) > 0)
                        {
                            StringBuilderResult.Append(buffer, 0, bytesRead);
                        }
                    }
                }
                result = StringBuilderResult.ToString();
                StringBuilderResult.Clear();
                return result;
            }
            catch (TaskCanceledException ex) when (cts.IsCancellationRequested)
            {
                logHelper.TLLog($"HttpClientSendAsyncStream����ʱ [url:{url}],[TraceID:{traceId}]", LogEnum.RunError);
                return null;
            }
            catch (HttpRequestException ex)
            {
                logHelper.ExceptionLog(ex, $"HttpClientSendAsyncStream�����쳣 [url:{url}],[TraceID:{traceId}]", LogEnum.RunException);
                return null;
            }
            catch (Exception ex)
            {
                logHelper.ExceptionLog(ex, $"HttpClientSendAsyncStream���ʷ������쳣��[url:{url}],[traceId:{traceId}],", LogEnum.RunException);
                return null;
            }
        }
        #endregion

    }
}