using System;
using System.Collections.Generic;
using System.Threading;
using HDL_ON.DAL.Server;
using HDL_ON.Entity;
using HDL_ON.UI;
using HDL_ON.UI.UI2.FuntionControlView.Video;
using HDL_ON.UI.UI2.Intelligence.Automation;
using Newtonsoft.Json;
using Shared;

namespace HDL_ON.Common
{
    public class ApiUtlis
    {
        public ApiUtlis()
        {
        }

        static ApiUtlis apiUtlis;
        public static ApiUtlis Ins
        {
            get
            {
                if (apiUtlis == null)
                {
                    apiUtlis = new ApiUtlis();
                }
                return apiUtlis;
            }
        }

        HttpServerRequest httpRequest;

        public HttpServerRequest HttpRequest
        {
            get
            {
                if (httpRequest == null)
                {
                    httpRequest = new HttpServerRequest();
                }
                return httpRequest;
            }
        }
        bool complateGetHomePagerInfo = false;
        bool complateGetUserInfo = false;
        bool complateGetRoomListInfo = false;
        bool complateGetGroupControl = false;
        bool complateGetSecurityListInfo = false;
        bool complateGetLogicListInfo = false;
        bool complateGet3tyInfo = false;
        bool complateDevice = false;
        bool complateScene = false;

        /// <summary>
        /// 下载数据完成标记
        /// </summary>
        public bool DownloadDataComplete = false;

        /// <summary>
        /// token是否有效
        /// </summary>
        public bool IsValidToken = true;

        /// <summary>
        /// 下载数据
        /// </summary>
        public void DownloadData()
        {
            IsValidToken = true;
            if (MainPage.NoLoginMode)
            {
                DownloadDataComplete = true;
                return;
            }

            MainPage.Log($"开始同步云端数据");
            DownloadDataComplete = false;

            var waitPage = new Loading();
            MainPage.BaseView.AddChidren(waitPage);
            waitPage.Start(Language.StringByID(StringId.PleaseWait));

            var downloadDataThread = new Thread(() =>
            {
                MainPage.Log($"进入读取云端数据线程");
                try
                {
                    #region ===================刷新Token=======================
                    var code = Ins.HttpRequest.RefreshToken();
                    if (code == StateCode.SUCCESS)
                    {
                        IsValidToken = true;
                        complateGetHomePagerInfo = complateGetUserInfo = complateGetRoomListInfo = complateGetGroupControl =
                        complateGetSecurityListInfo = complateGetLogicListInfo = complateGet3tyInfo = complateDevice = complateScene = false;
                    }
                    else
                    {
                        IsValidToken = false;
                        DownloadDataComplete = true;
                        complateGetHomePagerInfo = complateGetUserInfo = complateGetRoomListInfo = complateGetGroupControl =
                        complateGetSecurityListInfo = complateGetLogicListInfo = complateGet3tyInfo = complateDevice = complateScene = true;
                        //complateGetSecurityListInfo = false;
                    }
                    #endregion
                    if (IsValidToken)
                    {
                        #region ===================刷新住宅信息=======================
                        new Thread(() =>
                        {
                            code = Ins.HttpRequest.GetHomePager();
                            complateGetHomePagerInfo = true;
                        })
                        { IsBackground = true }.Start();
                        #endregion

                        #region ===================刷新个人信息=======================
                        new Thread(() =>
                        {
                            code = Ins.HttpRequest.GetUserInfo();
                            complateGetUserInfo = true;
                        })
                        { IsBackground = true }.Start();
                        #endregion

                        #region ===================房间=======================
                        new Thread(() =>
                        {
                            var roomResult = Ins.HttpRequest.GetRoomList();
                            if (roomResult.Code == StateCode.SUCCESS)
                            {
                                var revData = JsonConvert.DeserializeObject<SpatialApiPack>(roomResult.Data.ToString());
                                if (revData == null)
                                {
                                    revData = new SpatialApiPack();
                                }
                                SpatialInfo.CurrentSpatial.UpdateSpatialList(revData.list);
                                try
                                {
                                    var ssd = System.Text.Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(revData.list));
                                    FileUtlis.Files.WriteFileByBytes("SpatialInfoData", ssd);
                                }
                                catch (Exception ex)
                                {
                                    MainPage.Log("Error", $"{this.GetType()}:保存房间信息异常：{ex.StackTrace}");
                                }
                            }
                            complateGetRoomListInfo = true;
                        })
                        { IsBackground = true }.Start();
                        #endregion

                        #region ===================设备=======================
                        new Thread(() =>
                        {
                            try
                            {
                                var deviceResult = Ins.HttpRequest.GetDeviceList("30", "1");
                                if (deviceResult.Code == StateCode.SUCCESS)
                                {
                                    MainPage.Log($"读取设备信息成功");
                                    //MainPage.Log($"sid列表获取====\r\n", deviceResult.Data.ToString());
                                    var deviceList = JsonConvert.DeserializeObject<DevcieApiPack>(deviceResult.Data.ToString());
                                    if (deviceList == null)
                                    {
                                        deviceList = new DevcieApiPack();
                                    }
                                    try
                                    {
                                        while (deviceList.totalPage != deviceList.pageNo)
                                        {
                                            var deviceResult2 = Ins.HttpRequest.GetDeviceList("30", Convert.ToInt32(deviceList.pageNo) + 1 + "");
                                            if (deviceResult2.Code == StateCode.SUCCESS)
                                            {
                                                var deviceList2 = JsonConvert.DeserializeObject<DevcieApiPack>(deviceResult.Data.ToString());
                                                deviceList.pageNo = deviceList2.pageNo;
                                                deviceList.list.AddRange(deviceList2.list);
                                            }
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        MainPage.Log("Error", $"解析设备信息异常:{ex.StackTrace}");
                                    }

                                    string delFile = "";
                                    if (FunctionList.List.GetDeviceFunctionList().Count > 0)
                                    {
                                        for (int i = 0; i < FunctionList.List.GetDeviceFunctionList().Count;)
                                        {
                                            var localFunction = FunctionList.List.GetDeviceFunctionList()[i];
                                            var newFunction = deviceList.list.Find((obj) => obj.deviceId == localFunction.deviceId);

                                            if (delFile == localFunction.savePath)
                                            {
                                                i++;
                                                continue;
                                            }
                                            delFile = localFunction.savePath;
                                            FunctionList.List.DeleteFunction(localFunction);
                                        }
                                    }
                                    //处理剩下的新增功能
                                    foreach (var newDevice in deviceList.list)
                                    {
                                        newDevice.AssembleStatus();
                                        newDevice.SaveFunctionFile();
                                        FunctionList.List.IniFunctionList(newDevice.savePath, true);
                                    }


                                    //===================读取可视对讲数据==========================
                                    //判断是否有可视对讲数据，有则显示可视对讲icon
                                    //var flVideoInfo = HttpRequest.CheckFlVideo();
                                    //if(flVideoInfo.Code == StateCode.SUCCESS)
                                    //{
                                    //    FunctionList.List.videoIntercom1111 = Newtonsoft.Json.JsonConvert.DeserializeObject<UI.UI2.FuntionControlView.Video.VideoClouds>(flVideoInfo.Data.ToString());
                                    //}

                                    //======================获取可视对讲设备列表====================
                                    bool isInterphoneType_HDL = false;//是否为HDLLinphone可视对讲
                                    bool isInterphoneType_FREEVIEW = false;//是否为全视通可视对讲
                                    var videoInfo = VideoSend.GetVideoInfoList();
                                    if (videoInfo.Code == StateCode.SUCCESS)
                                    {
                                        string videoList = videoInfo.Data.ToString();
                                        FunctionList.List.videoIntercom = JsonConvert.DeserializeObject<List<UI.UI2.FuntionControlView.Video.Video>>(videoList);
                                        for (int i = 0; i < FunctionList.List.videoIntercom.Count; i++)
                                        {
                                            var video = FunctionList.List.videoIntercom[i];

                                            if (video.interphoneType == InterphoneType.HDL.ToString())
                                            {
                                                isInterphoneType_HDL = true;
                                                DB_ResidenceData.Instance.SupportFacePass = true;
                                                DB_ResidenceData.Instance.SaveResidenceData();
                                            }
                                        }
                                    }


                                    //======================获取Sip账号并且初始化SDK可视对讲设备列表====================
                                    //如果检测线程没启动，才继续下面操作 因为App有可能刚启动马上收到推送了，然后才执行到这里
                                    if (HDLLinphone.Current.CheckIncomingCallThreadIsNull())
                                    {
                                        //当前住宅是HDL可视对讲类型的设备
                                        if (isInterphoneType_HDL)
                                        {
                                            //HDLLinphone可视对讲,获取Sip账号并初始化SDK
                                            HDLCallVideoInfo callVideoInfo = new HDLCallVideoInfo();
                                            callVideoInfo.HomeId = DB_ResidenceData.Instance.CurrentRegion.id;
                                            callVideoInfo.InterphoneType = InterphoneType.HDL.ToString();
                                            HDLLinphone.Current.GetHDLSipInfoAndInitSDK(callVideoInfo);
                                        }
                                        else if (isInterphoneType_FREEVIEW)
                                        {
                                            //HDLLinphone可视对讲,获取Sip账号并初始化SDK
                                            HDLCallVideoInfo callVideoInfo = new HDLCallVideoInfo();
                                            callVideoInfo.HomeId = DB_ResidenceData.Instance.CurrentRegion.id;
                                            callVideoInfo.InterphoneType = InterphoneType.FREEVIEW.ToString();
                                            HDLLinphone.Current.GetHDLSipInfoAndInitSDK(callVideoInfo);
                                        }
                                        else
                                        {
                                            Utlis.WriteLine("当前住宅不支持HDL可视对讲,退出登录所有账号");
                                            //当前住宅不支持HDL可视对讲
                                            HDLLinphone.Current.LogoutAllAccount();
                                        }
                                    }

                                    //======================登录全视通====================
                                    if (isInterphoneType_FREEVIEW)
                                    {

#if __IOS__
                                        //string systemVersion = UIKit.UIDevice.CurrentDevice.SystemVersion;
                                        //string errorVersion = "16.2.0";
                                        //if (systemVersion.CompareTo(errorVersion) < 0)///全视通不兼容ios16以上的系统，不要加载这个先
                                        //{
                                        //    List<VisitorTempPassword> dataList = new List<VisitorTempPassword>();
                                        //    Dictionary<string, object> dictionary = new Dictionary<string, object>();
                                        //    dictionary.Add("homeId", Entity.DB_ResidenceData.Instance.CurrentRegion.id);
                                        //    var requestJson = HttpUtil.GetSignRequestJson(dictionary);
                                        //    ResponsePackNew pack = HttpUtil.RequestHttpsPost(NewAPI.Api_Post_GetExtMemberInfo, requestJson);
                                        //    if (pack != null)
                                        //    {
                                        //        var data = JsonConvert.DeserializeObject<FreeviewMemberInfo>(pack.Data.ToString());
                                        //        //登录全视通
                                        //        Shared.IOS.HDLFVSDK.Video.Init("", data.extUserId, DB_ResidenceData.Instance.CurrentRegion.id, "78FF1E4D-FC0A-4E71-9B79-0448E4460BD7", "T0001", "120.77.53.170:9700", "120.77.53.170:21664");
                                        //    }
                                        //}
#endif
                                    }

                                }
                                else
                                {
                                    MainPage.Log($"读取云端设备数据失败:Code:{deviceResult.Code};  Msg:{deviceResult.message}");
                                }
                            }
                            catch (Exception ex)
                            {
                                MainPage.Log("Error", $"============设备============{ex.StackTrace}");
                            }
                            finally
                            {
                                complateDevice = true;
                                MainPage.Log($"============设备============完成" + FunctionList.List.Functions.Count);
                            }
                        })
                        { IsBackground = true }.Start();
                        #endregion

                        #region ======================群控====================
                        new Thread(() =>
                        {
                            try
                            {
                                if (DB_ResidenceData.Instance.HomeGateway.isSupportGroupControl)
                                {
                                    var pack = Ins.HttpRequest.GetGroupControlList();
                                    if (pack != null)
                                    {
                                        if (pack.Code == StateCode.SUCCESS)
                                        {
                                            try
                                            {
                                                var groupControlList = JsonConvert.DeserializeObject<List<GroupControl>>(pack.Data.ToString());
                                                var readSidList = new List<string>();
                                                foreach (var temp in groupControlList)
                                                {
                                                    FunctionList.List.groupControls.Clear();
                                                    readSidList.Add(temp.userDeviceGroupControlId);
                                                    if (readSidList.Count >= 20)
                                                    {
                                                        var data = Ins.httpRequest.GetGroupControInfo(readSidList);
                                                        if (data != null)
                                                        {
                                                            if (data.Code == StateCode.SUCCESS)
                                                            {
                                                                var groupControlInfoList = JsonConvert.DeserializeObject<List<GroupControl>>(data.Data.ToString());
                                                                FunctionList.List.groupControls.AddRange(groupControlInfoList);
                                                            }
                                                            else
                                                            {
                                                                IMessageCommon.Current.ShowErrorInfoAlter(pack.Code);
                                                            }
                                                        }
                                                        readSidList.Clear();
                                                    }
                                                    //FunctionList.List.Functions.AddRange(FunctionList.List.groupControls);
                                                }
                                                if (readSidList.Count > 0)
                                                {
                                                    var data = Ins.httpRequest.GetGroupControInfo(readSidList);
                                                    if (data != null)
                                                    {
                                                        if (data.Code == StateCode.SUCCESS)
                                                        {
                                                            var groupControlInfoList = JsonConvert.DeserializeObject<List<GroupControl>>(data.Data.ToString());
                                                            FunctionList.List.groupControls.AddRange(groupControlInfoList);
                                                        }
                                                        else
                                                        {
                                                            IMessageCommon.Current.ShowErrorInfoAlter(pack.Code);
                                                        }
                                                    }
                                                    readSidList.Clear();
                                                }
                                            }
                                            catch (Exception ex)
                                            {
                                                MainPage.Log("Error", $"读取组控列表失败:{ex.StackTrace}");
                                            }
                                        }
                                        else
                                        {
                                            IMessageCommon.Current.ShowErrorInfoAlter(pack.Code);
                                        }
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                MainPage.Log($"群控：{ex.StackTrace}");
                            }
                            finally
                            {
                                complateGetGroupControl = true;
                            }
                        })
                        { IsBackground = true }.Start();
                        #endregion

                        #region ======================场景====================
                        new Thread(() =>
                        {
                            try
                            {
                                var pack = Ins.HttpRequest.GetSceneList();
                                if (pack.Code == StateCode.SUCCESS)
                                {
                                    MainPage.Log($"读取场景数据成功");
                                    var sceneList = JsonConvert.DeserializeObject<List<Scene>>(pack.Data.ToString());
                                    if (sceneList == null)
                                    {
                                        sceneList = new List<Scene>();
                                    }
                                    FunctionList.List.scenes.Clear();

                                    //处理剩下的新增功能
                                    foreach (var tempScene in sceneList)
                                    {
                                        tempScene.SaveSceneFile();
                                        FunctionList.List.scenes.Add(tempScene);
                                    }
                                    MainPage.Log($"读取场景数据成功:{FunctionList.List.scenes.Count}");

                                    //如果是一端口需要提前下载场景数据，否则控制不了一端口场景
                                    if (DB_ResidenceData.Instance.GatewayType == 0)
                                    {
                                        var sceneIds = new List<string>();
                                        foreach (var tempScene in FunctionList.List.scenes)
                                        {
                                            sceneIds.Add(tempScene.userSceneId);
                                        }
                                        var packInfo = HttpRequest.GetSceneListInfo(sceneIds);
                                        if (packInfo.Code == StateCode.SUCCESS)
                                        {
                                            var serverTempList = JsonConvert.DeserializeObject<List<Scene>>(packInfo.Data.ToString());
                                            foreach (var localScene in FunctionList.List.scenes)
                                            {
                                                var serverTemp = serverTempList.Find((obj) => obj.userSceneId == localScene.userSceneId);
                                                if (serverTemp != null)
                                                {
                                                    localScene.functions = serverTemp.functions;
                                                    localScene.SaveSceneFile();
                                                }
                                            }
                                        }
                                    }
                                }
                                else
                                {
                                    MainPage.Log($"读取云端场景数据失败:Code:{pack.Code}; Msg:{pack.message}");
                                }
                            }
                            catch (Exception ex)
                            {
                                MainPage.Log("Error", $"===场景==={ex.StackTrace}");
                            }
                            finally
                            {
                                complateScene = true;
                            }
                        })
                        { IsBackground = true }.Start();
                        #endregion

                        #region ======================安防====================
                        new Thread(() =>
                        {
                            try
                            {
                                GetSecurityList();
                            }
                            catch (Exception ex)
                            {
                                MainPage.Log($"安防：{ex.StackTrace}");
                            }
                            finally
                            {
                                complateGetSecurityListInfo = true;
                            }
                        })
                        { IsBackground = true }.Start();
                        #endregion

                        #region ======================读取逻辑列表====================
                        new Thread(() =>
                        {
                            try
                            {
                                Logic.LogicList.Clear();//主页下拉强制刷新自动化列表
                                MainView.GetLogicList();//读取自动化列表
                            }
                            catch (Exception ex)
                            {
                                MainPage.Log($"读取逻辑列表：{ex.StackTrace}");
                            }
                            finally
                            {
                                complateGetLogicListInfo = true;
                            }
                        })
                        { IsBackground = true }.Start();
                        #endregion

                        #region ======================注册推送====================
                        httpRequest.RegisteredPush();
                        #endregion

                        #region ======================第三方设备====================
                        new Thread(() =>
                        {
                            try
                            {
                                FunctionList.List.Read3tyFunctionStatus();
                            }
                            catch (Exception ex)
                            {
                                MainPage.Log("Error", "读取第三方设备状态失败:" + ex.StackTrace);
                            }
                            finally
                            {
                                complateGet3tyInfo = true;
                            }
                        })
                        { IsBackground = true }.Start();
                        #endregion
                    }

                    #region ===========终止下载线程===========
                    new Thread(() =>
                    {
                        try
                        {
                            int sleepCout = 0;
                            while (true)
                            {
                                if (complateGetHomePagerInfo && complateGetUserInfo && complateGetRoomListInfo && complateGetGroupControl &&
                                complateGetSecurityListInfo && complateGetLogicListInfo && complateGet3tyInfo && complateDevice && complateScene)
                                {
                                    break;
                                }
                                Thread.Sleep(100);
                                if (sleepCout > 150)
                                {
                                    MainPage.Log("=======超时，退出休眠=======");
                                    break;
                                }
                                else
                                {
                                    //MainPage.Log($"=======休眠，等待数据{sleepCout}=======");
                                    sleepCout++;
                                }
                            }
                            LoadLocalData();
                            Application.RunOnMainThread(() =>
                            {
                                if (waitPage != null)
                                {
                                    waitPage.RemoveFromParent();
                                    waitPage = null;
                                }
                            });
                        }
                        catch { }
                        finally
                        {
                            DownloadDataComplete = true;
                            if (DB_ResidenceData.Instance.CurrentRegion != null)
                            {
                                //不考虑网关情况，直接订阅
                                DAL.Mqtt.MqttClient.InitState();

                                #region 重置TCP客户端
                                try
                                {
                                    DriverLayer.Control.Ins.LocalTcpClientLogin = false;
                                    if (DriverLayer.Control.Ins.myTcpClient != null)
                                    {
                                        DriverLayer.Control.Ins.myTcpClient.Dispose();
                                        DriverLayer.Control.Ins.myTcpClient = null;
                                    }
                                }
                                catch (Exception ex)
                                {
                                    MainPage.Log("Error", $"重置TCP客户端异常:{ex.Message}");
                                }
                                #endregion

                                try
                                {
                                    DriverLayer.Control.Ins.SearchLoaclGateway();
                                }
                                catch (Exception ex)
                                {
                                    MainPage.Log("Error", $"搜索网关：{ex.StackTrace}");
                                }

                                try
                                {
                                    HomePage.LoadEvent_CheckTokenValid();
                                    if (!IsValidToken && UserInfo.Current.TipInvalidToken)
                                    {
                                        UserInfo.Current.TipInvalidToken = false;
                                        UserInfo.Current.SaveUserInfo();
                                        Application.RunOnMainThread(() =>
                                        {
                                            try
                                            {
                                                new PublicAssmebly().TipOptionMsg(StringId.Tip, StringId.TokenInvalidTipMsg, StringId.OfflineControl, StringId.GoLogin, () =>
                                                {
                                                    HDLCommon.Current.Logout();
                                                });
                                            }
                                            catch (Exception ex)
                                            {
                                                MainPage.Log("Error", $"提示登录凭证窗口加载异常:{ex.StackTrace}");
                                            }
                                        });
                                    }
                                }
                                catch (Exception ex)
                                {
                                    MainPage.Log("Error", $"更新登录凭证方法调用异常:{ex.StackTrace}");
                                }
                            }
                        }
                    })
                    { IsBackground = true }.Start();
                    #endregion

                }
                catch (Exception ex)
                {
                    MainPage.Log($"读取云端数据线程异常：{ex.StackTrace}");
                }
            });
            downloadDataThread.IsBackground = true;
            downloadDataThread.Priority = ThreadPriority.Highest;
            downloadDataThread.Start();

        }

        /// <summary>
        /// 获取安防列表
        /// </summary>
        public void GetSecurityList()
        {
            lock (FunctionList.List.securities)
            {
                try
                {
                    var pack = Ins.HttpRequest.GetSecurityList();
                    if (pack.Code == StateCode.SUCCESS)
                    {
                        var packList = JsonConvert.DeserializeObject<List<SecurityAlarm>>(pack.Data.ToString());
                        var sidList = new List<string>();
                        foreach (var function in packList)
                        {
                            sidList.Add(function.sid);
                        }
                        if (sidList.Count == 0)
                        {
                            return;
                        }
                        var infoListPack = Ins.httpRequest.GetSecurityInfo(sidList, new List<string>());
                        var infoList = JsonConvert.DeserializeObject<List<SecurityAlarm>>(infoListPack.Data.ToString());
                        if (infoList != null)
                        {
                            var filePathList = FileUtlis.Files.ReadFiles().FindAll((obj) => obj.StartsWith("SecurityData_"));
                            if (filePathList != null)
                            {
                                foreach (var file in filePathList)
                                {
                                    FileUtlis.Files.DeleteFile(file);
                                }
                            }
                            FunctionList.List.securities.Clear();
                            foreach (var function in infoList)
                            {
                                function.SaveFile();
                                FunctionList.List.IniFunctionList(function.savePath, true);
                            }
                        }
                    }
                    else
                    {
                        MainPage.Log($"读取安防列表失败:Code:{pack.Code}; Msg:{pack.message}");
                    }
                }
                catch (Exception ex)
                {
                    MainPage.Log("Error", $"读取安防列表失败:Code:{ex.StackTrace}");
                }
            }
        }

        /// <summary>
        /// 加载本地数据
        /// </summary>
        private void LoadLocalData()
        {
            MainPage.Log("=========APiUtlis开始加载数据=========");
            FunctionList.List.ClearDatas();
            try
            {
                var spatialInfoDataBytes = FileUtlis.Files.ReadFile("SpatialInfoData");
                if (spatialInfoDataBytes != null)
                {
                    var spatialInfoDataString = System.Text.Encoding.UTF8.GetString(spatialInfoDataBytes);
                    if (spatialInfoDataString != null && !string.IsNullOrEmpty(spatialInfoDataString))
                    {
                        var spatialInfoDataList = JsonConvert.DeserializeObject<List<SpatialInfo>>(spatialInfoDataString);
                        SpatialInfo.CurrentSpatial.UpdateSpatialList(spatialInfoDataList);
                    }
                }
            }
            catch (Exception ex)
            {
                MainPage.Log("Error", $"{this.GetType()}:加载缓存房间数据异常:{ex.StackTrace}");
            }

            try
            {
                var fileList = FileUtlis.Files.ReadFiles();
                foreach (var file in fileList)
                {
                    FunctionList.List.IniFunctionList(file, true);
                }
                Room.CurrentSpatial.InitRoomListFunctions();
            }
            catch (Exception ex)
            {
                MainPage.Log("Error", $"{this.GetType()}:加载缓存设备数据异常:{ex.StackTrace}");
            }

            MainPage.Log("=========APiUtlis完成加载数据=========");
        }
    }

}