using IOTContainer.Communication;
using IOTContainer.Model;
using IOTContainer.View;
using IOTContainer.ViewModel;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net;
using System.Net.Security;
using System.Runtime.InteropServices;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Markup;

namespace IOTContainer.Common
{
    public class HttpComm
    {
        public static HttpComm Http
        {
            get
            {
                if (_http == null)
                    _http = new HttpComm();
                return _http;
            }
        }
        public delegate void ScreenConfigDelegate();
        public event ScreenConfigDelegate ScreenConfigReceiveEvent;
        private static HttpComm _http;
        public string _httpUrl;
        private HttpComm()
        {
            _httpUrl = string.IsNullOrEmpty(ComParameters.Parameters.httpPort) ? ComParameters.Parameters.httpServer : ComParameters.Parameters.httpServer +":"+ ComParameters.Parameters.httpPort;
            //_httpUrl = ComParameters.Parameters.httpServer + ComParameters.Parameters.httpPort;
        }

        public string Get(string Url, string cookies = null)
        {
            try
            {
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(Url);
                request.Method = "GET";
                if (cookies != null)
                    request.Headers.Add("Cookie", cookies);
                request.ContentType = "application/x-www-form-urlencoded";
                ServicePointManager.Expect100Continue = true;
                ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls;
                ServicePointManager.ServerCertificateValidationCallback = (sender, certificate, chain, errors) => true;
                HttpWebResponse response = (HttpWebResponse)request.GetResponse();             
                string encoding = response.ContentEncoding;
                if (encoding == null || encoding.Length < 1)
                {
                    encoding = "UTF-8"; //默认编码  
                }
                StreamReader reader = new StreamReader(response.GetResponseStream(), Encoding.GetEncoding(encoding));
                string retString = reader.ReadToEnd();
                return retString;
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile($"地址为：{Url}{ex.ToString()}");
                return "Error";
            }
        }
        private void init_Request(ref HttpWebRequest request)
        {
            request.Accept = "text/json,*/*;q=0.5";
            request.Headers.Add("Accept-Charset", "utf-8;q=0.7,*;q=0.7");
            request.Headers.Add("Accept-Encoding", "gzip, deflate, x-gzip, identity; q=0.9");
            request.AutomaticDecompression = DecompressionMethods.GZip;
            request.Timeout = 60000;
        }

        public string Post(string url, string data, string contentType = "application/x-www-form-urlencoded; charset=utf-8", Dictionary<string, string> headers = null)
        {
            try
            {
                var request = (HttpWebRequest)WebRequest.Create(url);
                {
                    string retval;
                    init_Request(ref request);
                    request.Method = "POST";
                    request.ContentType = contentType;
                    if (headers != null && headers.Count > 0)
                    {
                        foreach (var h in headers)
                        {
                            request.Headers.Add(h.Key, h.Value);
                        }
                    }
                    ServicePointManager.Expect100Continue = true;
                    ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls;
                    ServicePointManager.ServerCertificateValidationCallback = (sender, certificate, chain, errors) => true;
                    var bytes = System.Text.Encoding.UTF8.GetBytes(data);
                    request.ContentLength = bytes.Length;
                    using (var stream = request.GetRequestStream())
                    {
                        stream.Write(bytes, 0, bytes.Length);
                    }
                    using (var response = request.GetResponse())
                    {
                        using (var reader = new System.IO.StreamReader(response.GetResponseStream() ?? throw new InvalidOperationException()))
                        {
                            retval = reader.ReadToEnd();
                        }
                    }
                    return retval;
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile(ex.ToString());
                return "Error";
            }
        }
        public string Request(string Method, string url, Dictionary<string, object> dic = null, string ContentType = null, string data = null, JObject json = null, string headers = null, string cookies = null, string UserAgent = null, int Timeout = 30000, string Referer = null, string Proxy = null, bool KeepAlive = true)
        {
            try
            {
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
                request.Method = Method;
                request.Referer = Referer ?? null;
                request.KeepAlive = KeepAlive;
                request.Timeout = Timeout;
                request.ServerCertificateValidationCallback = delegate { return true; };
                request.Headers.Add("cookie", cookies);
                request.UserAgent = UserAgent ?? "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.113 Safari/537.36";
                request.ServicePoint.Expect100Continue = false;
                if (Proxy != null)
                {
                    WebProxy WebProxy = new WebProxy(Proxy);
                    request.Proxy = WebProxy;
                }

                if (Method != "GET")
                {
                    byte[] bytePost = { };
                    if (data != null)
                    {
                        request.ContentType = "application/json;charset=utf-8";
                        bytePost = Encoding.UTF8.GetBytes(data.ToString());
                    }
                    if (json != null)
                    {
                        request.ContentType = "application/json;charset=utf-8";
                        bytePost = Encoding.UTF8.GetBytes(json.ToString());
                    }
                    if (dic != null)
                    {
                        request.ContentType = "application/x-www-form-urlencoded;charset=utf-8";
                        string param = "";
                        for (int count = 0; count < dic.Count; count++)
                            param += dic.ElementAt(count).Key + "=" + dic.ElementAt(count).Value.ToString() + "&";
                        bytePost = Encoding.UTF8.GetBytes(param.ToString());
                    }

                    request.ContentLength = bytePost.Length;
                    request.GetRequestStream().Write(bytePost, 0, bytePost.Length);
                    request.GetRequestStream().Close();
                }

                HttpWebResponse response = (HttpWebResponse)request.GetResponse();
                StreamReader myStreamReader = new StreamReader(response.GetResponseStream(), Encoding.GetEncoding("utf-8"));
                string r = myStreamReader.ReadToEnd();
                myStreamReader.Close();
                return r;
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("Request：" + ex.ToString());
                return null;
            }
        }
        private bool RemoteCertificateValidate(
           object sender, X509Certificate cert,
            X509Chain chain, SslPolicyErrors error)
        {
            return true;
        }
        /// <summary>
        /// 下载文件
        /// </summary>
        /// <param name="fileUrl">下载地址</param>
        /// <param name="localFileName">本地文件名</param>
        /// <param name="folderPath">文件夹完整路径</param>
        /// <param name="cover">是否覆盖同名文件</param>
        /// <returns></returns>
        private string DownLoadFile(string fileUrl, string localFileName, string folderPath, bool cover = false)
        {
            var filePath = "";
            try
            {
                if (!Directory.Exists(folderPath))
                {
                    Directory.CreateDirectory(folderPath);
                }
                if (File.Exists(folderPath + "/" + localFileName))
                {
                    if (!cover)
                    {
                        return filePath;
                    }
                    else
                    {
                        File.Delete(folderPath + "/" + localFileName);
                    }
                }
                if (File.Exists(folderPath + "/" + localFileName + ".temp"))
                {
                    File.Delete(folderPath + "/" + localFileName + ".temp");
                }
                using (Stream fileStream = new FileStream(folderPath + "/" + localFileName + ".temp", FileMode.OpenOrCreate))
                {
                    try
                    {
                        HttpWebRequest request = (HttpWebRequest)WebRequest.Create(fileUrl);
                        request.AddRange(fileStream.Length);
                        ServicePointManager.ServerCertificateValidationCallback += RemoteCertificateValidate;
                        HttpWebResponse respone = (HttpWebResponse)request.GetResponse();
                        using (Stream netStream = respone.GetResponseStream())
                        {
                            long totalDownloadedByte = 0;
                            byte[] read = new byte[1024];
                            int realReadLen = netStream.Read(read, 0, read.Length);
                            while (realReadLen > 0)
                            {
                                totalDownloadedByte = realReadLen + totalDownloadedByte;

                                fileStream.Write(read, 0, realReadLen);
                                realReadLen = netStream.Read(read, 0, read.Length);

                                System.Windows.Forms.Application.DoEvents();
                            }
                            netStream.Close();
                        }
                        if (fileStream.Length != respone.ContentLength)
                        {
                            Log.MyLog.WriteLogFile("文件未下载完毕");
                        }
                        fileStream.Close();
                        Log.MyLog.WriteLogFile("下载完成" + folderPath + "/" + localFileName, "FileDownload");
                        File.Move(folderPath + "/" + localFileName + ".temp", folderPath + "/" + localFileName);
                        filePath = folderPath + "/" + localFileName;


                        //var fileHash = GetMD5HashFromFile(folderPath + "/" + localFileName);
                        //if (fileHash != hash)
                        //{
                        //    log.WriteLogFile("localFile    " + fileHash + "      getHash:" + hash, "exelog");
                        //    File.Delete(folderPath + "/" + localFileName);
                        //    log.WriteLogFile("FileHash对比不一致，须删除重新下载" + folderPath + "/" + localFileName, "exelog");
                        //    return false;
                        //}

                    }
                    catch (Exception ex)
                    {
                        fileStream.Close();
                        Log.MyLog.WriteLogFile($"下载失败:源地址{fileUrl}，本地地址：" + folderPath + "/" + localFileName + ex.ToString());
                        File.Delete(folderPath + "/" + localFileName + ".temp");
                        return "";
                    }
                }
                return filePath;
            }
            catch (Exception e)
            {
                Log.MyLog.WriteLogFile("下载失败:源地址:" + fileUrl + e.ToString());
                return "";
            }
        }

        /// <summary>
        /// 表单上传
        /// </summary>
        /// <param name="url"></param>
        /// <param name="path"></param>
        /// <returns></returns>
        public string UploadFile(string url, string filePath, Dictionary<string, string> formDatas, string contentType = "multipart/form-data;")
        {
            var returnValue = "";
            // 时间戳，用做boundary
            string timeStamp = DateTime.Now.Ticks.ToString("x");

            //根据uri创建HttpWebRequest对象
            HttpWebRequest httpReq = (HttpWebRequest)WebRequest.Create(new Uri(url));
            httpReq.Method = "POST";
            httpReq.AllowWriteStreamBuffering = false; //对发送的数据不使用缓存
            httpReq.Timeout = 300000; //设置获得响应的超时时间（300秒）
            httpReq.ContentType = "multipart/form-data; boundary=" + timeStamp;

            //读取file文件
            FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
            BinaryReader binaryReader = new BinaryReader(fileStream);
            try
            {
                //表单信息
                string boundary = "--" + timeStamp;
                string form = "";
                string formFormat = boundary + "\r\nContent-Disposition: form-data; name=\"{0}\"\r\n\r\n{1}\r\n";
                string formEnd = boundary + "\r\nContent-Disposition: form-data; name=\"{0}\"; filename=\"{1}\";\r\nContent-Type:application/octet-stream\r\n\r\n";
                foreach (var pair in formDatas)
                {
                    form += string.Format(formFormat, pair.Key, pair.Value);
                }
                form += string.Format(formEnd, "file", Path.GetFileName(filePath));
                byte[] postHeaderBytes = Encoding.UTF8.GetBytes(form);

                //结束边界
                byte[] boundaryBytes = Encoding.ASCII.GetBytes("\r\n--" + timeStamp + "--\r\n");
                long length = fileStream.Length + postHeaderBytes.Length + boundaryBytes.Length;
                httpReq.ContentLength = length; //请求内容长度

                //每次上传4k
                int bufferLength = 4096;
                byte[] buffer = new byte[bufferLength];

                //已上传的字节数
                long offset = 0;
                int size = binaryReader.Read(buffer, 0, bufferLength);
                Stream postStream = httpReq.GetRequestStream();

                //发送请求头部消息
                postStream.Write(postHeaderBytes, 0, postHeaderBytes.Length);

                while (size > 0)
                {
                    postStream.Write(buffer, 0, size);
                    offset += size;
                    size = binaryReader.Read(buffer, 0, bufferLength);
                }

                //添加尾部边界
                postStream.Write(boundaryBytes, 0, boundaryBytes.Length);
                postStream.Close();

                //获取服务器端的响应
                using (HttpWebResponse response = (HttpWebResponse)httpReq.GetResponse())
                {
                    ServicePointManager.Expect100Continue = true;
                    ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls;
                    ServicePointManager.ServerCertificateValidationCallback = (sender, certificate, chain, errors) => true;
                    Stream receiveStream = response.GetResponseStream();
                    StreamReader readStream = new StreamReader(receiveStream, Encoding.UTF8);
                    returnValue = readStream.ReadToEnd();
                    response.Close();
                    readStream.Close();
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("文件传输异常： " + ex.ToString());
            }
            finally
            {
                fileStream.Close();
                binaryReader.Close();
            }
            return returnValue;
        }
        /// <summary>
        /// 测试MQTT连接是否可用
        /// </summary>
        public void IsMqttConnect()
        {
            var result = "";
            try
            {
                string api = "/api/mqtt/v1/client/ping";
                string httpUri = _httpUrl + api + "?machineCode=" + ComParameters.Parameters.devCode;
                result = Get(httpUri);
                Log.MyLog.WriteLogFile("httpUri：" + httpUri + Environment.NewLine + "result：" + result, "MQTT连接测试");
                if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                {
                    var jo = JObject.Parse(result);
                    string code = jo.Value<string>("code");
                    if (code != "200")
                    {
                        Log.MyLog.WriteLogFile("MQTT连接不可用：" + jo.Value<string>("msg"), "MQTT连接测试");
                    }
                    else
                    {
                        Log.MyLog.WriteLogFile("MQTT连接可用：" + jo.Value<string>("msg"), "MQTT连接测试");
                    }
                }
                else
                {
                    Log.MyLog.WriteLogFile("测试MQTT连接：" + result, "MQTT连接测试");
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("测试MQTT连接异常：" + ex, "MQTT连接测试");
            }
        }
        /// <summary>
        /// 测试连接
        /// </summary>
        /// <param name="url"></param>
        /// <param name="timeout"></param>
        /// <returns></returns>
        public static bool IsCanConnect(string url, int timeout = 3000)
        {
            HttpWebResponse res = null;
            bool CanCn = true;
            try
            {
                HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);
                req.Method = "HEAD";
                req.Timeout = timeout;
                res = (HttpWebResponse)req.GetResponse();
                CanCn = res.StatusCode.ToString() == "OK";
            }
            catch (Exception ex)
            {
                CanCn = false;   //无法连接 
            }
            finally
            {
                if (res != null)
                {
                    res.Close();
                }
            }
            return CanCn;
        }


        #region 接口
        /// <summary>
        /// 获得待注册设备信息
        /// </summary>
        /// <returns></returns>
        public string Register()
        {
            var result = "";
            try
            {
                string api = "/api/device/v1/client/register" +
                    "";
                string httpUri = _httpUrl + api + "?code=" + ComParameters.Parameters.registerCode;
                result = Get(httpUri);
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("获得待注册设备信息异常：" + ex);
            }
            return result;
        }
        /// <summary>
        /// 设备激活
        /// </summary>
        /// <returns></returns>
        public void Activate(out string msg)
        {
            msg = "";
            try
            {
                var label = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "windows" : "android";
                var width = (int)SystemParameters.PrimaryScreenWidth;
                var height = (int)SystemParameters.PrimaryScreenHeight;
                var screenType = width > height ? "横" : "竖";
                var resolution = $"{width}*{height}{screenType}屏";
                var ip = SystemManage.GetLocalIp();
                var mac = SystemManage.GetMac();
                var dic = new Dictionary<string, string>();
                dic.Add("label", label);
                dic.Add("resolution", resolution);
                dic.Add("ip", ip);
                dic.Add("mac", mac);
                dic.Add("code", ComParameters.Parameters.devCode);
                LocalStorage.InsertPipTable("infos", ConfigKey.label, label);
                LocalStorage.InsertPipTable("infos", ConfigKey.resolution, resolution);
                LocalStorage.InsertPipTable("infos", ConfigKey.ip, ip);
                LocalStorage.InsertPipTable("infos", ConfigKey.mac, mac);
                ComParameters.Parameters.label = label;
                ComParameters.Parameters.resolution = resolution;
                ComParameters.Parameters.ip = ip;
                ComParameters.Parameters.mac = mac;
                var api = "/api/device/v1/client/active";
                var httpUri = $"{_httpUrl}{api}";
                var body = JsonConvert.SerializeObject(dic);
                var contentType = "application/json; charset=utf-8";
                var result = Post(httpUri, body, contentType);
                if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                {
                    var jo = JObject.Parse(result);
                    string code = jo.Value<string>("code");
                    if (code == "200")
                    {
                        var content = jo.Value<JObject>("data");
                        var mqtt = content.ToObject<MQTTModel>();
                        if (mqtt != null)
                        {
                            LocalStorage.InsertPipTable("infos", ConfigKey.mqttServer, mqtt.Server);
                            LocalStorage.InsertPipTable("infos", ConfigKey.mqttPort, mqtt.Port);
                            ComParameters.Parameters.mqttPort = Convert.ToInt32(mqtt.Port);
                            ComParameters.Parameters.mqttServer = mqtt.Server;
                        }
                    }
                    else
                    {
                        msg = jo.Value<string>("msg");
                        Log.MyLog.WriteLogFile("激活设备失败：" + msg);
                    }
                }
                else
                {
                    Log.MyLog.WriteLogFile("激活设备失败：" + result);
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("设备激活异常：" + ex);
            }
        }
        /// <summary>
        /// 设备信息
        /// </summary>
        public void DeviceInfo()
        {
            try
            {
                var dic = new Dictionary<string, string>();
                dic.Add("devName", ComParameters.Parameters.devName);
                dic.Add("width", SystemParameters.PrimaryScreenWidth.ToString());
                dic.Add("height", SystemParameters.PrimaryScreenHeight.ToString());
                dic.Add("ip", SystemManage.GetLocalIp());
                dic.Add("mac", SystemManage.GetMac());
                dic.Add("code", ComParameters.Parameters.devCode);
                dic.Add("serverIP", ComParameters.Parameters.httpServer);
                dic.Add("appVersion", ComParameters.Parameters.containerVersion);
                dic.Add("programVersion", ComParameters.Parameters.webVersion);
                Log.MyLog.WriteLogFile(JsonConvert.SerializeObject(dic), "DeviceInfo");
            }
            catch (Exception ex)
            {

                Log.MyLog.WriteLogFile("设备信息异常：" + ex.ToString(), "DeviceInfo");
            }
            
        }
        /// <summary>
        /// 上传版本号
        /// </summary>
        public void UploadVersion()
        {
            try
            {
                var width = (int)SystemParameters.PrimaryScreenWidth;
                var height = (int)SystemParameters.PrimaryScreenHeight;
                var screenType = width > height ? "横" : "竖";
                var resolution = $"{width}*{height}{screenType}屏";
                var ip = SystemManage.GetLocalIp();
                var dic = new Dictionary<string, string>();
                dic.Add("code", ComParameters.Parameters.devCode);
                dic.Add("appVersion", ComParameters.Parameters.containerVersion);
                dic.Add("programVersion", ComParameters.Parameters.webVersion);
                dic.Add("ip", ip);
                dic.Add("resolution", resolution);
                var api = "/api/device/v1/client/version";
                var httpUri = $"{_httpUrl}{api}";
                var body = JsonConvert.SerializeObject(dic);
                var contentType = "application/json; charset=utf-8";
                var result = Post(httpUri, body, contentType);
                if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                {
                    var jo = JObject.Parse(result);
                    string code = jo.Value<string>("code");
                    string msg = jo.Value<string>("msg");
                    if (code == "200")
                    {
                        //Log.MyLog.WriteLogFile("版本号上传成功：" + msg);
                    }
                    else
                    {
                        Log.MyLog.WriteLogFile("版本号上传失败：" + msg);
                    }
                }
                else
                {
                    Log.MyLog.WriteLogFile("版本号上传失败：" + result);
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("版本号上传异常：" + ex.ToString());
            }
        }
        /// <summary>
        /// 获取屏保
        /// </summary>
        public void GetProtectation()
        {
            try
            {
                string api = "/api/device/v1/client/getProtection";
                string httpUri = $"{_httpUrl}{api}?projectCode={ComParameters.Parameters.projectCode}&code={ComParameters.Parameters.devCode}";
                var result = Get(httpUri);
                if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                {
                    var jo = JObject.Parse(result);
                    string code = jo.Value<string>("code");
                    if (code != "200")
                    {
                        Log.MyLog.WriteLogFile("获取屏保失败：" + jo.Value<string>("msg"));
                    }
                    else
                    {
                        var data = jo.Value<JObject>("data");
                        var model = data.ToObject<ProtectionModel>();
                        if (model != null)
                        {
                            LocalStorage.InsertPipTable("infos", ConfigKey.noTouchingSeconds, model.protectionTime);
                            ComParameters.Parameters.noTouchingSeconds = Convert.ToInt32(model.protectionTime);
                            if (string.IsNullOrEmpty(model.jumpTime))
                                model.jumpTime = "0";
                            LocalStorage.InsertPipTable("infos", ConfigKey.jumpTime, model.jumpTime);
                            ComParameters.Parameters.jumpTime = Convert.ToInt32(model.jumpTime);
                            LocalStorage.InsertPipTable("infos", ConfigKey.labelType, model.type.ToString());
                            ComParameters.Parameters.labelType = model.type.ToString();
                            LocalStorage.InsertPipTable("infos", ConfigKey.labelEffect, model.protectionEffect);
                            ComParameters.Parameters.labelEffect = model.protectionEffect;
                            LocalStorage.InsertPipTable("infos", ConfigKey.labelLocation, model.protectionLocation);
                            ComParameters.Parameters.labelLocation = model.protectionLocation;
                            if (!string.IsNullOrEmpty(model.url))
                            {
                                var fileName = Guid.NewGuid().ToString() + model.url.Substring(model.url.LastIndexOf("."));
                                var filePath = DownLoadFile(ComParameters.Parameters.downloadUrl + model.url, fileName, Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "ScreenSaver"), true);
                                var fileHash = FileManage.GetMD5HashFromFile(filePath);
                                if (fileHash == ComParameters.Parameters.screenSaverHash)//相同删除临时文件
                                {
                                    File.Delete(filePath);
                                }
                                else//不同则删除前文件
                                {
                                    if (!string.IsNullOrEmpty(ComParameters.Parameters.screenSaver))
                                    {
                                        File.Delete(ComParameters.Parameters.screenSaver);
                                    }
                                    LocalStorage.InsertPipTable("infos", ConfigKey.screenSaver, filePath);
                                    LocalStorage.InsertPipTable("infos", ConfigKey.screenSaverHash, fileHash);
                                    ComParameters.Parameters.screenSaver = filePath;
                                    //if (ComParameters.Parameters.ScreenViewModel != null)
                                    //{
                                    //    ComParameters.Parameters.ScreenViewModel.ScreenSaverPath = filePath;
                                    //}
                                    ComParameters.Parameters.screenSaverHash = fileHash;
                                }
                            }
                            if (!string.IsNullOrEmpty(model.customUrl))
                            {
                                var fileName = Guid.NewGuid().ToString() + model.customUrl.Substring(model.customUrl.LastIndexOf("."));
                                var filePath = DownLoadFile(ComParameters.Parameters.downloadUrl + model.customUrl, fileName, Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "ScreenSaver"), true);
                                var fileHash = FileManage.GetMD5HashFromFile(filePath);
                                if (fileHash == ComParameters.Parameters.screenSaverTouchHash)//相同删除临时文件
                                {
                                    File.Delete(filePath);
                                }
                                else//不同则删除前文件
                                {
                                    if (!string.IsNullOrEmpty(ComParameters.Parameters.screenSaverTouch))
                                    {
                                        File.Delete(ComParameters.Parameters.screenSaverTouch);
                                    }
                                    LocalStorage.InsertPipTable("infos", ConfigKey.screenSaverTouch, filePath);
                                    LocalStorage.InsertPipTable("infos", ConfigKey.screenSaverTouchHash, fileHash);
                                    ComParameters.Parameters.screenSaverTouch = filePath;
                                    //if (ComParameters.Parameters.ScreenViewModel != null)
                                    //{
                                    //    ComParameters.Parameters.ScreenViewModel.ScreenSaverPath = filePath;
                                    //}
                                    ComParameters.Parameters.screenSaverTouchHash = fileHash;
                                }
                            }
                        }
                    }
                }
                else
                {
                    Log.MyLog.WriteLogFile("获取屏保失败：" + result);
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("获取屏保异常：" + ex);
            }
        }
        /// <summary>
        /// 同步服务器时间
        /// </summary>
        public void getCurrentTimestamp()
        {
            try
            {
                string api = "/api/data/v1/util/getCurrentTimestamp";
                string httpUri = $"{_httpUrl}{api}";
                var result = Get(httpUri);
                Log.MyLog.WriteLogFile("同步服务器时间：" + result, "getCurrentTimestamp");
                if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                {
                    var jo = JObject.Parse(result);
                    string code = jo.Value<string>("code");
                    if (code != "200")
                    {
                        Log.MyLog.WriteLogFile("同步服务器时间失败：" + jo.Value<string>("msg"));
                    }
                    else
                    {
                        try
                        {
                            var data = jo.Value<long>("data");
                            Log.MyLog.WriteLogFile("同步服务器时间：" + ConvertExtension.GetDateTime(data), "getCurrentTimestamp");
                            SyncServerTime.SystemHelper.SetLocalMachineTime(ConvertExtension.GetDateTime(data));
                        }
                        catch (Exception tx)
                        {

                            Log.MyLog.WriteLogFile("同步服务器时间异常：" + tx);
                        }

                    }
                }
                else
                {
                    Log.MyLog.WriteLogFile("获取服务器时间失败：" + result);
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("同步服务器时间异常：" + ex);
            }

        }
        /// <summary>
        /// 获取APP和应用的更新包
        /// </summary>
        public void GetAppPackage()
        {
            try
            {
                string api = "/api/device/v1/deviceWeb/getMachineAppProgramMsg";
                string httpUri = $"{_httpUrl}{api}?code={ComParameters.Parameters.devCode}";
                var result = Get(httpUri);
                Log.MyLog.WriteLogFile("GetAppPackage：" + result, "HttpComm");
                if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                {
                    var jo = JObject.Parse(result);
                    string code = jo.Value<string>("code");
                    if (code == "200")
                    {
                        var data = jo.Value<JObject>("data");
                        var model = data.ToObject<GetAppPackageModel>();
                        if (model != null)
                        {
                            var programVersion = model.programVersion;
                            var programPackageUrl = model.programPackageUrl;
                            var appVersion = model.appVersion;
                            var appPackageUrl = model.appPackageUrl;
                            if (!string.IsNullOrEmpty(programPackageUrl) && !programVersion.Equals(ComParameters.Parameters.webVersion))
                            {

                                var name = $"{DateTime.Now.ToString("yyyy-MM-dd")}_h5_{programVersion}.zip";
                                var folder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "UpgradeFile");
                                var filePath = DownLoadFile(programPackageUrl, name, folder, true);
                                if (!string.IsNullOrEmpty(filePath))
                                {
                                    var tempDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "UpdateTempH5");
                                    var destDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "www");
                                    if (!Directory.Exists(tempDir)) Directory.CreateDirectory(tempDir);
                                    if (!Directory.Exists(destDir)) Directory.CreateDirectory(destDir);
                                    try
                                    {
                                        ZipFile.ExtractToDirectory(filePath, tempDir);
                                        var dir = new DirectoryInfo(tempDir).GetDirectories();
                                        if (dir == null || !dir.Any())
                                        {
                                            Log.MyLog.WriteLogFile("应用升级失败：文件夹内容为空！", "cmdexelog");
                                        }
                                        else
                                        {
                                            //SystemManage.CopyDireToDire(dir[0].FullName, destDir);
                                            SystemManage.CopyDireToDire(tempDir, destDir);
                                            //配置数据库写入版本号                                  
                                            ComParameters.Parameters.webVersion = programVersion;
                                            LocalStorage.InsertPipTable("infos", ConfigKey.webVersion, programVersion);
                                            ComParameters.Parameters.MainWindow.Dispatcher.Invoke(() =>
                                            {
                                                ComParameters.Parameters.VersionInfoViewModel.WebVersion = programVersion;

                                            });
                                            //上传版本号
                                            Http.UploadVersion();
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        Log.MyLog.WriteLogFile("应用升级失败：" + ex.Message, "cmdexelog");
                                    }
                                    finally
                                    {
                                        Directory.Delete(tempDir, true);
                                        File.Delete(filePath);
                                    }
                                }
                                else
                                {
                                    ComParameters.Parameters.MessBoxViewModel.Detail = "应用下发异常,请重新下发";
                                }
                            }
                            if (!string.IsNullOrEmpty(appPackageUrl) && !appVersion.Equals(ComParameters.Parameters.containerVersion))
                            {                                
                                var name = $"{DateTime.Now.ToString("yyyy-MM-dd")}_co_{appVersion}.zip";
                                var filePath = DownLoadFile(appPackageUrl, name, Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "UpgradeFile"), true);
                                ComParameters.Parameters.containerVersion = appVersion;
                                LocalStorage.InsertPipTable("infos", ConfigKey.containerVersion, appVersion);
                                if (!string.IsNullOrEmpty(filePath))
                                {
                                    ExternalCall.StartExE(AppDomain.CurrentDomain.BaseDirectory + "ConUpdate.exe", true, filePath);
                                    ExternalCall.CloseContainerServiceLoader();
                                    Environment.Exit(0);
                                }

                            }
                        }
                    }
                }
                else
                {
                    Log.MyLog.WriteLogFile("获取APP和应用的更新包失败：" + result);
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("获取APP和应用的更新包异常：" + ex);
            }
        }
        /// <summary>
        /// 设备获得密码
        /// </summary>
        /// <returns></returns>
        public string GetPwd()
        {
            var pwd = "";
            try
            {
                var dic = new Dictionary<string, string>();
                dic.Add("code", ComParameters.Parameters.devCode);
                if (!string.IsNullOrEmpty(ComParameters.Parameters.devCode))
                {
                    var api = "/api/device/v1/client/token";
                    var httpUri = $"{_httpUrl}{api}";
                    var body = JsonConvert.SerializeObject(dic);
                    var contentType = "application/json; charset=utf-8";
                    var result = Post(httpUri, body, contentType);
                    if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                    {
                        var jo = JObject.Parse(result);
                        string code = jo.Value<string>("code");
                        if (code == "200")
                        {
                            var content = jo.Value<JObject>("data");
                            pwd = content.Value<string>("password");
                            LocalStorage.InsertPipTable("infos", ConfigKey.pwd, pwd);
                            ComParameters.Parameters.pwd = pwd;
                        }
                        else
                        {
                            pwd = ComParameters.Parameters.devCode;
                            Log.MyLog.WriteLogFile("获取设备密码失败：" + jo.Value<string>("msg"));
                        }
                    }
                    else
                    {
                        pwd = ComParameters.Parameters.devCode;
                        Log.MyLog.WriteLogFile("获取设备密码失败：" + result);
                    }
                }
            }
            catch (Exception ex)
            {
                pwd = ComParameters.Parameters.devCode;
                Log.MyLog.WriteLogFile("设备获得密码异常：" + ex);
            }
            return pwd;
        }
        /// <summary>
        /// 上传截图
        /// </summary>
        public void UploadScreenShot()
        {
            try
            {
                var fileName = $"{ComParameters.Parameters.devCode.Replace("-", "")}-{DateTime.Now.ToString("yyMMddhhmmssffff")}.jpg";
                var filePath = SystemManage.PrintScreen(fileName);
                if (string.IsNullOrEmpty(filePath))
                {
                    Log.MyLog.WriteLogFile("上传截图失败：截图为空！");
                }
                else
                {
                    string api = "/api/device/v1/client/screenShort";
                    var dic = new Dictionary<string, string>();
                    dic.Add("code", ComParameters.Parameters.devCode);
                    dic.Add("timestamp", DateTime.Now.GetMilliTimeStamp().ToString());
                    string httpUri = _httpUrl + api;
                    var result = UploadFile(httpUri, filePath, dic);
                    if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                    {
                        var jo = JObject.Parse(result);
                        string code = jo.Value<string>("code");
                        if (code != "200")
                        {
                            Log.MyLog.WriteLogFile("上传截图失败：" + jo.Value<string>("msg"));
                        }
                    }
                    else
                    {
                        Log.MyLog.WriteLogFile("上传截图失败：" + result);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("上传截图异常：" + ex);
            }
        }
        /// <summary>
        /// 获取文件服务器地址
        /// </summary>
        public void GetDownloadUrl()
        {
            try
            {
                //if (string.IsNullOrEmpty(ComParameters.Parameters.downloadUrl))
                //{
                    string api = "/api/data/v1/web/getUploadUrl";
                    string httpUri = _httpUrl + api;
                    var result = Get(httpUri);
                    if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                    {
                        var jo = JObject.Parse(result);
                        string code = jo.Value<string>("code");
                        if (code != "200")
                        {
                            Log.MyLog.WriteLogFile("获取文件服务器地址失败：" + jo.Value<string>("msg"));
                        }
                        else
                        {
                            var data = jo.Value<string>("data");
                            ComParameters.Parameters.downloadUrl = data;
                            LocalStorage.InsertPipTable("infos", ConfigKey.downloadUrl, data);
                        }
                    }
                    else
                    {
                        Log.MyLog.WriteLogFile("获取文件服务器地址失败：" + result);
                    }
                //}
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("获取文件服务器地址异常：" + ex);
            }
        }
        /// <summary>
        /// 开机设备开关机时间
        /// </summary>
        public void getMachineOnOffTime()
        {
            try
            {
                string api = "/api/device/v1/deviceWeb/getMachineOnOffTime";
                string httpUri = $"{_httpUrl}{api}?code={ComParameters.Parameters.devCode}";
                var result = Get(httpUri);
                if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                {
                    var jo = JObject.Parse(result);
                    string code = jo.Value<string>("code");
                    if (code != "200")
                    {
                        Log.MyLog.WriteLogFile("获取设备开关机时间失败：" + jo.Value<string>("msg"));
                    }
                    else
                    {
                        var cont = jo.Value<JObject>("data");
                        var timeModel = cont.Value<JObject>("time");
                        var time = timeModel.Value<string>("off");
                        if(string.IsNullOrEmpty(time))
                        {
                            List<MachineOnOffTimeModel> itemList = timeModel.Value<JArray>("weekList").ToObject<List<MachineOnOffTimeModel>>();
                            if (itemList.Count == 7)
                            {
                                ExternalCall.ClearShutDownTime();
                                int day = 0;
                                foreach (var item in itemList)
                                {
                                    day++;
                                    switch (day)
                                    {
                                        case 1:
                                            ExternalCall.SetWeekShutDownTime("Mon", item.off);
                                            break;
                                        case 2:
                                            ExternalCall.SetWeekShutDownTime("Tue", item.off);
                                            break;
                                        case 3:
                                            ExternalCall.SetWeekShutDownTime("Wed", item.off);
                                            break;
                                        case 4:
                                            ExternalCall.SetWeekShutDownTime("Thu", item.off);
                                            break;
                                        case 5:
                                            ExternalCall.SetWeekShutDownTime("Fri", item.off);
                                            break;
                                        case 6:
                                            ExternalCall.SetWeekShutDownTime("Sat", item.off);
                                            break;
                                        case 7:
                                            ExternalCall.SetWeekShutDownTime("Sun", item.off);
                                            break;
                                        default:
                                            break;
                                    }
                                }
                            }                            
                            else if (itemList.Count == 0)
                            {                               
                                ExternalCall.DeleteWeekShutDownTime();
                                ExternalCall.ClearShutDownTime();
                            }
                        }
                        else
                        {
                            ExternalCall.DeleteWeekShutDownTime();
                            ExternalCall.SetDayShutDownTime(time);
                        }
                        
                    }
                }
                else
                {
                    Log.MyLog.WriteLogFile("获取设备开关机时间失败：" + result);
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("获取设备开关机时间异常：" + ex);
            }
        }
        
        /// <summary>
        /// 获取设备节目列表
        /// </summary>
        public async Task GetProgram()
        {
            try
            {
                var data = new JArray();
                #region 获取新节目列表
                string api = "/api/info/v1/web/getProgramByDeviceCode";
                string httpUri = _httpUrl + api + "?code=" + ComParameters.Parameters.devCode;
                var result = Get(httpUri);
                if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                {
                    var jo = JObject.Parse(result);
                    string code = jo.Value<string>("code");
                    //记录节目日志

                    Log.MyLog.WriteLogFile(result, "ProgrammeList");

                    if (code != "200")
                    {
                        Log.MyLog.WriteLogFile("获取设备节目列表失败：" + jo.Value<string>("msg"));
                    }
                    data = jo.Value<JArray>("data");
                }
                else
                {
                    Log.MyLog.WriteLogFile("获取设备节目列表失败：" + result);
                }
                #endregion
                #region 获取现在的节目列表"ProgrammeList.txt"
                var folderName = "Programme";
                var basePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, folderName);
                var programmeListName = "ProgrammeList.txt";
                //删除文件时得排除在外
                var exceptList = new List<string> { programmeListName, "SubtitleList.txt" };
                var filePath = Path.Combine(basePath, programmeListName);
                if (!Directory.Exists(basePath))
                {
                    Directory.CreateDirectory(basePath);
                }
                ComParameters.rwl.EnterReadLock();
                var content = FileManage.ReadJsonFile(filePath);
                ComParameters.rwl.ExitReadLock();
                List<ProgrammeModel> nowProgrammeList = null;
                if (!string.IsNullOrEmpty(content))
                {
                    nowProgrammeList = JsonConvert.DeserializeObject<List<ProgrammeModel>>(content);
                }

                #endregion

                var proList = data.ToString();
                var programmeList = data.ToObject<List<ProgrammeModel>>();

                #region 删除 现列表和新列表以外的节目（每次只保存上一次和这一次的节目）
                if (!string.IsNullOrEmpty(content))
                {
                    await Task.Run(() =>
                    {
                        var files = new DirectoryInfo(basePath).GetFiles().Select(p => p.Name);
                        var allProgrammeList = nowProgrammeList.Union(programmeList).Select(p => p.Img.Substring(p.Img.LastIndexOf("/") + 1));
                        var toRemoveFiles = files.Except(allProgrammeList).Where(p => !exceptList.Contains(p));
                        foreach (var item in toRemoveFiles)
                        {
                            File.Delete(basePath + "/" + item);
                        }
                    });
                }
                #endregion
                #region 更新列表文件并下载节目
                ComParameters.rwl.EnterWriteLock();
                FileManage.WriteJsonFile(filePath, proList);
                ComParameters.rwl.ExitWriteLock();
                foreach (var item in programmeList)
                {
                    var fileName = item.Img.Substring(item.Img.LastIndexOf("/") + 1);
                    if (!File.Exists(basePath + "/" + fileName))
                    {
                        DownLoadFile(ComParameters.Parameters.downloadUrl + item.Img, fileName, basePath);
                    }
                }
                #endregion
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("获取设备节目列表异常：" + ex);
            }
        }
        /// <summary>
        /// 获取字幕
        /// </summary>
        public void GetSubtitle()
        {
            try
            {
                string api = "/api/info/v1/web/getSubtitlesByDeviceCode";
                string httpUri = _httpUrl + api + "?code=" + ComParameters.Parameters.devCode;
                var result = Get(httpUri);
                if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                {
                    var jo = JObject.Parse(result);
                    string code = jo.Value<string>("code");
                    if (code != "200")
                    {
                        Log.MyLog.WriteLogFile("获取字幕失败：" + jo.Value<string>("msg"));
                    }
                    //记录字幕日志
                    Task.Run(() =>
                    {
                        Log.MyLog.WriteLogFile(result, "SubtitleList");
                    });
                    var data = jo.Value<JArray>("data");
                    var proList = data.ToString();
                    #region 写入文件
                    var folderName = "Programme";
                    var basePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, folderName);
                    var programmeListName = "SubtitleList.txt";
                    var filePath = Path.Combine(basePath, programmeListName);
                    if (!Directory.Exists(basePath))
                    {
                        Directory.CreateDirectory(basePath);
                    }
                    ComParameters.srwl.EnterWriteLock();
                    FileManage.WriteJsonFile(filePath, proList);
                    ComParameters.srwl.ExitWriteLock();
                    #endregion
                }
                else
                {
                    Log.MyLog.WriteLogFile("获取字幕失败：" + result);
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("获取字幕异常：" + ex);
            }
        }
        /// <summary>
        /// 上传日志文件
        /// </summary>
        /// <param name="day"></param>
        /// <param name="msg"></param>
        public void UploadLogFile(int day, string msg = "")
        {
            var initiator = "";
            if (!string.IsNullOrEmpty(msg))
            {
                var jo = JObject.Parse(msg);
                var cont = jo.Value<JObject>("data");
                if (cont.HasValues)
                {
                    initiator = cont.Value<string>("initiator");
                }
            }
            var yest = DateTime.Now.AddDays(day).ToString("yyyy-MM-dd");
            var startPath = AppDomain.CurrentDomain.BaseDirectory + @"\log\" + yest;
            var zipPath = AppDomain.CurrentDomain.BaseDirectory + @"\log\" + yest + "Log.zip";
            try
            {
                if (!Directory.Exists(startPath))
                {
                    Log.MyLog.WriteLogFile("上传日志文件失败：文件路径未找到：" + startPath, "HttpWarning");
                }
                else
                {
                    ZipFile.CreateFromDirectory(startPath, zipPath, CompressionLevel.Fastest, true);
                    string api = "/api/device/v1/client/log";
                    var dic = new Dictionary<string, string>();
                    dic.Add("code", ComParameters.Parameters.devCode);
                    dic.Add("initiator", initiator);
                    dic.Add("type", day == 0 ? "1" : "0");//0-自动 1-手动
                    string httpUri = _httpUrl + api;
                    var result = UploadFile(httpUri, zipPath, dic);
                    if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                    {
                        var jo = JObject.Parse(result);
                        string code = jo.Value<string>("code");
                        if (code != "200")
                        {
                            Log.MyLog.WriteLogFile("上传日志文件失败：路径为 " + zipPath + jo.Value<string>("msg"));
                        }
                    }
                    else
                    {
                        Log.MyLog.WriteLogFile("上传日志文件失败：路径为 " + zipPath + result);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("上传日志文件异常：" + ex);
            }
            finally
            {
                if (File.Exists(zipPath))
                {
                    File.Delete(zipPath);
                }
            }
        }
        /// <summary>
        /// 获取离线接口列表
        /// </summary>
        public void GetInterfaceApi()
        {
            try
            {
                string api = "/api/device/v1/deviceWeb/getInterfaceApi";
                string httpUri = _httpUrl + api + "?projectCode=" + ComParameters.Parameters.projectCode;
                var result = Get(httpUri);
                if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                {
                    var jo = JObject.Parse(result);
                    string code = jo.Value<string>("code");
                    if (code != "200")
                    {
                        Log.MyLog.WriteLogFile("获取离线接口列表失败：" + jo.Value<string>("msg"));
                    }
                    else
                    {
                        var data = jo.Value<JArray>("data");
                        var proList = data.ToString();
                        var interfaceList = data.ToObject<List<InterfaceModel>>();
                        #region 下载离线接口文件
                        var baseDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "www", "static", "offline", "JSON");
                        if (!Directory.Exists(baseDir))
                        {
                            Directory.CreateDirectory(baseDir);
                        }
                        if (interfaceList.Any())
                        {
                            var error = new List<InterfaceModel>();
                            foreach (var item in interfaceList)
                            {
                                Task.Run(() =>
                                {
                                    var temp = "";
                                    if (item.name == "getDevCoordinateByIP")//极特殊接口
                                    {
                                        temp = Get(item.url + "?code=" + ComParameters.Parameters.devCode);
                                        if (!string.IsNullOrEmpty(temp) && temp.Contains("\"code\""))
                                        {
                                            var joByIP = JObject.Parse(temp);
                                            string codeByIP = joByIP.Value<string>("code");
                                            if (codeByIP == "200")
                                            {
                                                var contByIP = joByIP.Value<JObject>("data");
                                                var deployType = contByIP.Value<string>("deployType");
                                                if(deployType == "local")
                                                {
                                                    var xfyunIp = contByIP.Value<string>("xfyunIp");
                                                    var xfyunPort = contByIP.Value<string>("xfyunPort");
                                                    var baiduVoiceServer = contByIP.Value<string>("baiduVoiceServer");
                                                    ComParameters.Parameters.xfyunIp = xfyunIp;
                                                    LocalStorage.InsertPipTable("infos", ConfigKey.xfyunIp, xfyunIp);
                                                    ComParameters.Parameters.xfyunPort = xfyunPort;
                                                    LocalStorage.InsertPipTable("infos", ConfigKey.xfyunPort, xfyunPort);
                                                    ComParameters.Parameters.baiduVoiceServer = baiduVoiceServer;
                                                    LocalStorage.InsertPipTable("infos", ConfigKey.baiduVoiceServer, baiduVoiceServer);
                                                }
                                                else
                                                {
                                                    LocalStorage.DelPipRow("infos", ConfigKey.xfyunIp);
                                                    LocalStorage.DelPipRow("infos", ConfigKey.xfyunPort);
                                                    LocalStorage.DelPipRow("infos", ConfigKey.baiduVoiceServer);
                                                }
                                            }
                                        }
                                    }
                                    //else if (item.name.ToLower() == "getweather")
                                    //{
                                    //    temp = Get(item.url);
                                    //}
                                    else if (item.url.Contains("?"))
                                    {
                                        temp = Get(item.url + "&projectCode=" + ComParameters.Parameters.projectCode);
                                    }
                                    else
                                    {
                                        switch (item.method)
                                        {
                                            case "get":
                                                {
                                                    temp = Get(item.url + "?projectCode=" + ComParameters.Parameters.projectCode);
                                                    break;
                                                }
                                            case "post":
                                                {
                                                    temp = Post(item.url + "?projectCode=" + ComParameters.Parameters.projectCode, item.parameter);
                                                    break;
                                                }
                                        }
                                    }

                                    if (temp == "Error" || !temp.Contains("\"code\":200"))
                                    {
                                        Log.MyLog.WriteLogFile("下载离线接口文件失败：" + item.url);
                                        error.Add(item);
                                    }
                                    else
                                    {
                                        FileManage.WriteJsonFile($"{baseDir}\\{item.name}.json", temp);
                                    }
                                });
                            }
                            if (error.Any())
                            {
                                foreach (var item in error)
                                {
                                    var temp = "";
                                    if (item.name == "getDevCoordinateByIP")
                                    {
                                        temp = Get(item.url + "?code=" + ComParameters.Parameters.devCode);
                                    }
                                    //else if (item.name.ToLower() == "getweather")
                                    //{
                                    //    temp = Get(item.url);
                                    //}
                                    else if (item.url.Contains("?"))
                                    {
                                        temp = Get(item.url + "&projectCode=" + ComParameters.Parameters.projectCode);
                                    }
                                    else
                                    {
                                        switch (item.method)
                                        {
                                            case "get":
                                                {
                                                    temp = Get(item.url + "?projectCode=" + ComParameters.Parameters.projectCode);
                                                    break;
                                                }
                                            case "post":
                                                {
                                                    temp = Post(item.url + "?projectCode=" + ComParameters.Parameters.projectCode, item.parameter);
                                                    break;
                                                }
                                        }
                                    }

                                    if (temp == "Error" || !temp.Contains("\"code\":200"))
                                    {
                                        Log.MyLog.WriteLogFile("下载离线接口文件失败：" + item.url);
                                    }
                                    else
                                    {
                                        FileManage.WriteJsonFile($"{baseDir}\\{item.name}.json", temp);
                                    }
                                }
                            }
                        }
                        #endregion
                    }
                }
                else
                {
                    Log.MyLog.WriteLogFile("获取离线接口列表失败：" + result);
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("获取离线接口列表异常：" + ex);
            }
        }
        /// <summary>
        /// 获取资源列表
        /// </summary>
        public void GetFileSource()
        {
            try
            {
                string api = "";
                //if (ConfigurationManager.AppSettings["IsNewKiosk"] == "0")
                //{
                //    api = "/api/guidance/v1/web/getFileResource";
                //}
                //else
                //{
                //    api = "/api/guide/v1/web/getFileResource";
                //}
                api = "/api/data/v1/web/getFileResource";
                string httpUri = _httpUrl + api + "?projectCode=" + ComParameters.Parameters.projectCode;
                var result = Get(httpUri);
                //Log.MyLog.WriteLogFile("接口地址：" + httpUri + Environment.NewLine + "获取资源列表：" + result);
                if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                {
                    var jo = JObject.Parse(result);
                    string code = jo.Value<string>("code");
                    if (code != "200")
                    {
                        Log.MyLog.WriteLogFile("获取资源列表失败：" + jo.Value<string>("msg"));
                    }
                    else
                    {
                        var data = jo.Value<JArray>("data");
                        var fileList = data.ToObject<FileSourceModel[]>();
                        var newList = fileList.Select(p => p.url).ToArray();
                        var baseDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "www", "static", "offline");
                        if (!Directory.Exists(baseDir))
                        {
                            Directory.CreateDirectory(baseDir);
                        }
                        ComParameters.Parameters.MessageViewModel.Message = $"获取离线资源文件 0/{newList.Length}";
                        for (int i = 0; i < newList.Length; i++)
                        {
                            ComParameters.Parameters.MessageViewModel.Message = $"获取离线资源文件 {i + 1}/{newList.Length}";
                            string[] online = newList[i].Split('?');
                            newList[i] = online[0];
                            var filePathName = $"{baseDir}{newList[i].Substring(newList[i].IndexOf("/"), newList[i].LastIndexOf("/") - newList[i].IndexOf("/"))}";
                            if (!File.Exists(filePathName))
                            {
                                //按照下载链接的文件夹格式存文件，如"/iotFile/2022/06/20/eeb85afd46da4d83abbf467f41a27135.jpg" 那么 需要在"/iotFile/2022/06/20/"的文件夹下存"eeb85afd46da4d83abbf467f41a27135.jpg"
                                DownLoadFile(ComParameters.Parameters.downloadUrl + newList[i], newList[i].Substring(newList[i].LastIndexOf("/") + 1), $"{baseDir}{newList[i].Substring(newList[i].IndexOf("/"), newList[i].LastIndexOf("/") - newList[i].IndexOf("/"))}");
                            }
                        }
                    }
                }
                else
                {
                    Log.MyLog.WriteLogFile("获取资源失败：" + result);
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("获取资源列表异常：" + ex);
            }
        }
        /// <summary>
        /// 获取品牌列表Json文件
        /// </summary>
        /// <param name="baseDir"></param>
        public void Getbrand_listJson(string baseDir, string controlsCode)
        {
            try
            {
                string api = "/api/msg/v1/client/getApi/" + controlsCode;
                string httpUri = _httpUrl + api;
                var result = Get(httpUri);
                if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                {
                    var jo = JObject.Parse(result);
                    string code = jo.Value<string>("code");
                    if (code != "200")
                    {
                        Log.MyLog.WriteLogFile("获取品牌列表Json文件接口失败：" + jo.Value<string>("msg"));
                    }
                    else
                    {
                        JArray data = (JArray)jo["data"];
                        if (data.Count > 0)
                        {
                            string jsonText = null;
                            foreach (JObject list in data)
                            {
                                string fileName = (string)list.GetValue("interfaceName");
                                string interfaceUrl = (string)list.GetValue("interfaceUrl");
                                if (interfaceUrl.Contains("code="))
                                    interfaceUrl = interfaceUrl.Replace("code=", "code=" + ComParameters.Parameters.devCode);
                                if (interfaceUrl.Contains(_httpUrl))
                                {
                                    jsonText = Get(interfaceUrl);
                                }
                                else
                                {
                                    jsonText = Get(_httpUrl + interfaceUrl); 
                                }
                                if (!Directory.Exists(baseDir))
                                {
                                    Directory.CreateDirectory(baseDir);
                                }
                                string jsonPath = $"{baseDir}\\{fileName}.json";

                                if (File.Exists(jsonPath))
                                {
                                    File.Delete(jsonPath);
                                }
                                FileManage.WriteJsonFile(jsonPath, jsonText);
                            }
                        }
                    }
                }
                else
                {
                    Log.MyLog.WriteLogFile("获取品牌列表Json文件接口失败：" + result);
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("获取品牌列表Json文件接口异常：" + ex);
            }
        }
        /// <summary>
        /// 获取品牌列表资源文件
        /// </summary>
        /// <param name="baseDir"></param>
        public void Getbrand_listResource(string baseDir,string controlsCode)
        {
            try
            {
                string api = "/api/msg/v1/client/getFileResourceList/" + controlsCode;
                string httpUri = _httpUrl + api ;
                var result = Get(httpUri);
                if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                {
                    var jo = JObject.Parse(result);
                    string code = jo.Value<string>("code");
                    if (code != "200")
                    {
                        Log.MyLog.WriteLogFile("获取品牌列表资源失败：" + jo.Value<string>("msg"));
                    }
                    else
                    {
                        var data = jo.Value<JArray>("data");
                        var fileList = data.ToObject<FileSourceModel[]>();
                        var newList = fileList.Select(p => p.url).ToArray();
                        if (!Directory.Exists(baseDir))
                        {
                            Directory.CreateDirectory(baseDir);
                        }
                        for (int i = 0; i < newList.Length; i++)
                        {
                            string[] online = newList[i].Split('?');
                            newList[i] = online[0];
                            var filePathName = $"{baseDir}{newList[i].Substring(newList[i].IndexOf("/"), newList[i].LastIndexOf("/") - newList[i].IndexOf("/"))}";
                            if (!File.Exists(filePathName))
                            {
                                //按照下载链接的文件夹格式存文件，如"/iotFile/2022/06/20/eeb85afd46da4d83abbf467f41a27135.jpg" 那么 需要在"/iotFile/2022/06/20/"的文件夹下存"eeb85afd46da4d83abbf467f41a27135.jpg"
                                DownLoadFile(ComParameters.Parameters.downloadUrl + newList[i], newList[i].Substring(newList[i].LastIndexOf("/") + 1), $"{baseDir}{newList[i].Substring(newList[i].IndexOf("/"), newList[i].LastIndexOf("/") - newList[i].IndexOf("/"))}");
                            }
                        }
                    }
                }
                else
                {
                    Log.MyLog.WriteLogFile("获取品牌列表资源失败：" + result);
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("获取品牌列表资源异常：" + ex);
            }
        }
        /// <summary>
        /// 模型资源列表
        /// </summary>
        public void GetModelFileResource(string baseDir)
        {
            try
            {
                string api = "/api/guidance/v1/web/getModelFileResource";               
                string httpUri = _httpUrl + api + "?projectCode=" + ComParameters.Parameters.projectCode;
                var result = Get(httpUri);
                if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                {
                    var jo = JObject.Parse(result);
                    string code = jo.Value<string>("code");
                    if (code != "200")
                    {
                        Log.MyLog.WriteLogFile("获取模型资源列表失败：" + jo.Value<string>("msg"));
                    }
                    else
                    {
                        var data = jo.Value<JArray>("data");
                        var fileList = data.ToObject<FileSourceModel[]>();
                        var newList = fileList.Select(p => p.url).ToArray();                       
                        if (!Directory.Exists(baseDir))
                        {
                            Directory.CreateDirectory(baseDir);
                        }                       
                        for (int i = 0; i < newList.Length; i++)
                        {
                            string[] online = newList[i].Split('?');
                            newList[i] = online[0];
                            var filePathName = $"{baseDir}{newList[i].Substring(newList[i].IndexOf("/"), newList[i].LastIndexOf("/") - newList[i].IndexOf("/"))}";
                            if (!File.Exists(filePathName))
                            {
                                //按照下载链接的文件夹格式存文件，如"/iotFile/2022/06/20/eeb85afd46da4d83abbf467f41a27135.jpg" 那么 需要在"/iotFile/2022/06/20/"的文件夹下存"eeb85afd46da4d83abbf467f41a27135.jpg"
                                DownLoadFile(ComParameters.Parameters.downloadUrl + newList[i], newList[i].Substring(newList[i].LastIndexOf("/") + 1), $"{baseDir}{newList[i].Substring(newList[i].IndexOf("/"), newList[i].LastIndexOf("/") - newList[i].IndexOf("/"))}");
                            }
                        }
                    }
                }
                else
                {
                    Log.MyLog.WriteLogFile("获取模型资源失败：" + result);
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("获取模型资源列表异常：" + ex);
            }
        }
        /// <summary>
        /// 容器升级
        /// </summary>
        /// <param name="msg"></param>
        public void AppUpdate(string msg)
        {
            try
            {
                var jo = JObject.Parse(msg);
                var cont = jo.Value<JObject>("data");
                if (cont.HasValues)
                {
                    var updateModel = cont.ToObject<AppUpdateModel>();
                    var obj = updateModel?.update;
                    if (obj == null)
                    {
                        Log.MyLog.WriteLogFile("容器升级失败：接收数据对象为空！", "cmdexelog");
                    }
                    var version = obj.version;
                    if (version.Equals(ComParameters.Parameters.containerVersion))
                    {
                        return;
                    }
                    ComParameters.Parameters.containerVersion = version;
                    LocalStorage.InsertPipTable("infos", ConfigKey.containerVersion, version);
                    var url = obj.url;
                    if (string.IsNullOrEmpty(url))
                    {
                        Log.MyLog.WriteLogFile("容器升级失败：接收地址为空！", "cmdexelog");
                    }
                    else
                    {
                        var name = $"{DateTime.Now.ToString("yyMMddhhmmssffff")}.zip";
                        var filePath = DownLoadFile(url, name, Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "UpgradeFile"), true);
                        if (!string.IsNullOrEmpty(filePath))
                        {
                            ExternalCall.StartExE(AppDomain.CurrentDomain.BaseDirectory + "ConUpdate.exe", true, filePath);
                            ExternalCall.ContainerServiceLoaderDelay(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "IOTContainer.exe"));
                            ComParameters.Parameters.EdgeWindow.Dispatcher.Invoke(() =>
                            {
                                ComParameters.Parameters.EdgeWindow.Close();
                            });
                            Environment.Exit(0);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("容器升级异常：" + ex.Message, "cmdexelog");
            }
        }
        /// <summary>
        /// 应用升级
        /// </summary>
        /// <param name="msg"></param>
        internal void H5Update(string msg)
        {
            try
            {
                //ExternalCall.CheckStartExplorer();
               
                var jo = JObject.Parse(msg);
                var cont = jo.Value<JObject>("data");
                if (cont.HasValues)
                {
                    var updateModel = cont.ToObject<AppUpdateModel>();
                    var obj = updateModel?.update;
                    var version = obj.version;
                    var url = obj.url;
                    if(version.Equals(ComParameters.Parameters.webVersion))
                    {
                        return;
                    }
                    ComParameters.Parameters.MainWindow.Dispatcher.Invoke(() =>
                    {
                        var mess = new View.MessBoxWindow()
                        {
                            Owner = Application.Current.MainWindow,
                            WindowStartupLocation = WindowStartupLocation.CenterOwner,
                        };
                        mess.Show();
                        ComParameters.Parameters.MessBoxViewModel.Text = "应用升级";

                    });
                    if (obj == null)
                    {
                        Log.MyLog.WriteLogFile("应用升级失败：接收数据对象为空！", "cmdexelog");
                    }
                   
                    if (string.IsNullOrEmpty(url))
                    {
                        Log.MyLog.WriteLogFile("应用升级失败：接收地址为空！", "cmdexelog");
                    }
                    else
                    {
                        var name = $"{DateTime.Now.ToString("yyyy-MM-dd")}_h5_{version}.zip";
                        var folder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "UpgradeFile");
                        ComParameters.Parameters.MessBoxViewModel.Detail = "开始下载资源文件...";
                        var filePath = DownLoadFile(url, name, folder, true);
                        ComParameters.Parameters.MessBoxViewModel.Detail = "资源文件下载完成...";
                        if (!string.IsNullOrEmpty(filePath))
                        {
                            var tempDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "UpdateTempH5");
                            var destDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "www");
                            if (!Directory.Exists(tempDir)) Directory.CreateDirectory(tempDir);
                            if (!Directory.Exists(destDir)) Directory.CreateDirectory(destDir);
                            try
                            {
                                ComParameters.Parameters.MessBoxViewModel.Detail = "资源文件升级中...";
                                ZipFile.ExtractToDirectory(filePath, tempDir);
                                var dir = new DirectoryInfo(tempDir).GetDirectories();
                                if (dir == null || !dir.Any())
                                {
                                    Log.MyLog.WriteLogFile("应用升级失败：文件夹内容为空！", "cmdexelog");
                                }
                                else
                                {
                                    //SystemManage.CopyDireToDire(dir[0].FullName, destDir);
                                    SystemManage.CopyDireToDire(tempDir, destDir);
                                    //配置数据库写入版本号                                  
                                    ComParameters.Parameters.webVersion = version;
                                    LocalStorage.InsertPipTable("infos", ConfigKey.webVersion, version);
                                    ComParameters.Parameters.VersionInfoViewModel.WebVersion = version;
                                    //上传版本号
                                    Http.UploadVersion();
                                    ComParameters.Parameters.MessBoxViewModel.Detail = "资源文件升级完成...";
                                    ComParameters.Parameters.MessBoxWindow.Dispatcher.Invoke(() =>
                                    {
                                        ComParameters.Parameters.MessBoxWindow.Close();
                                    });
                                    //ComParameters.Parameters.MainWindow.Dispatcher.Invoke(() =>
                                    //{
                                    //    var web = new EdgeWindow();
                                    //    web.Close();
                                    //});
                                    //Thread.Sleep(2000);
                                    if (null == ComParameters.Parameters.EdgeWindow)
                                    {
                                        ComParameters.Parameters.MainWindow.Dispatcher.Invoke(() =>
                                        {
                                            var web = new EdgeWindow();
                                            web.Show();
                                            WinApi.FindSetTop(null, "EdgeWindow");
                                        });
                                    }
                                    else
                                    {
                                        ComParameters.Parameters.EdgeWindow.Dispatcher.Invoke(() =>
                                        {
                                            ComParameters.Parameters.EdgeWindow.Reload();
                                            ComParameters.Parameters.EdgeWindow.Activate();
                                        });
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                Log.MyLog.WriteLogFile("应用升级失败：" + ex.Message, "cmdexelog");
                            }
                            finally
                            {
                                Directory.Delete(tempDir, true);
                                File.Delete(filePath);
                            }
                        }
                        else
                        {
                            ComParameters.Parameters.MessBoxViewModel.Detail = "应用下发异常,请重新下发";
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("应用升级异常：" + ex.Message, "cmdexelog");
            }
        }
        /// <summary>
        /// 上传节目播放记录
        /// </summary>
        /// <param name="programId"></param>
        /// <param name="proType"></param>
        public async void UploadPlayDetail(string programCode, string duration, int proType = 1)
        {
            try
            {
                await Task.Run(() =>
                {
                    var url = _httpUrl + "/api/analysis/v1/web/deviceUseClickDataUpload";
                    Dictionary<string, object> json = new Dictionary<string, object>(){
                    { "projectCode", ComParameters.Parameters.projectCode},
                    { "deviceCode",ComParameters.Parameters.devCode},
                    { "tag", "performance" },
                    { "programId", null },
                    { "proType",1},
                    { "performanceCode", programCode },
                    { "duration", duration},
                };
                    var result = Post(url, JsonConvert.SerializeObject(json), "application/json; charset=utf-8");
                    Log.MyLog.WriteLogFile(result, "UploadPlayDetail");
                    if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                    {
                        var jo = JObject.Parse(result);
                        string code = jo.Value<string>("code");
                        if (code != "200")
                        {
                            Log.MyLog.WriteLogFile("上传节目播放记录失败：" + jo.Value<string>("msg"));
                        }
                    }
                    else
                    {
                        Log.MyLog.WriteLogFile("上传节目播放记录失败：" + result);
                    }
                });
                
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("上传节目播放记录异常：" + ex.Message);
            }
        }
        /// <summary>
        /// 导视点击数据上报
        /// </summary>
        public void UploadClickData()
        {
            try
            {
                var data = new Dictionary<string, object>();
                var url = _httpUrl + "/api/analysis/v1/web/guideClickDataUpload";
                var result = Post(url, "{\"projectCode\":\"" + ComParameters.Parameters.projectCode + "\",\"deviceCode\":\"" + ComParameters.Parameters.devCode + "\",\"recordType\":\"3\",\"moduleName\":\"\",\"activityCode\":\"\"}", "application/json; charset=utf-8");
                if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                {
                    var jo = JObject.Parse(result);
                    string code = jo.Value<string>("code");
                    if (code != "200")
                    {
                        Log.MyLog.WriteLogFile("上传导视点击数据失败：" + jo.Value<string>("msg"));
                    }
                }
                else
                {
                    Log.MyLog.WriteLogFile("上传导视点击数据失败：" + result);
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("上传导视点击数据异常：" + ex.Message);
            }
        }
        /// <summary>
        /// 获取同屏组主设备信息
        /// </summary>
        public void QueryPrimaryMachine(object noUse)
        {
            try
            {
                var result = Get(_httpUrl + "/api/device/v1/client/getPrimaryMachine?code=" + ComParameters.Parameters.devCode);
                if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                {
                    //result = "{\"code\":\"200\",\"data\":{\"ip\":\"192.168.1.242\"}}";
                    var jo = JObject.Parse(result);
                    string code = jo.Value<string>("code");
                    if (code != "200")
                    {
                        Log.MyLog.WriteLogFile("获取同屏组主设备信息失败：" + jo.Value<string>("msg"));
                    }
                    else
                    {
                        var data = jo.Value<JObject>("data");
                        if (data.HasValues)
                        {
                            if (ComParameters.Parameters.MainMachineIp != data.Value<string>("ip"))//有变化则开始监听
                            //if (ComParameters.Parameters.MainMachineIp != data.Value<string>("ip") || (ComParameters.Parameters.IsSync && ComParameters.Parameters.WebSocketIsConnected == false))//有变化则开始监听
                            {
                                ComParameters.Parameters.IsSync = true;
                                ComParameters.Parameters.MainMachineIp = data.Value<string>("ip");
                                if (ComParameters.Parameters.MainMachineIp == ComParameters.Parameters.ip)
                                {
                                    //主设备
                                    ComParameters.Parameters.IsMainMachine = true;
                                    WebSocketCom.Socket.OpenSocketServer($"ws://{ComParameters.Parameters.MainMachineIp}:{ComParameters.Parameters.SocketPort}");
                                }
                                else
                                {
                                    //从设备
                                    ComParameters.Parameters.IsMainMachine = false;
                                    WebSocketCom.Socket.ListenWebSocket($"ws://{ComParameters.Parameters.MainMachineIp}:{ComParameters.Parameters.SocketPort}");
                                }
                                //TimeJobs.Jobs.StopQuerySyncMachine();
                            }
                        }
                        else
                        {
                            ComParameters.Parameters.IsSync = false;
                            ComParameters.Parameters.MainMachineIp = "";
                            WebSocketCom.Socket.StopWebSocketServer();
                            WebSocketCom.Socket.StopListen();
                        }
                    }
                }
                else
                {
                    Log.MyLog.WriteLogFile("获取同屏组主设备信息失败：" + result);
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("获取同屏组主设备信息异常：" + ex.Message);
            }
        }
        /// <summary>
        /// 下载分屏节目
        /// </summary>
        public void DownResource()
        {
            Task ac = new Task(() =>//静默下载离线文件
            {
                try
                {
                    string api = "/api/msg/v1/web/getScheduleByMachineCode";
                    string httpUri = _httpUrl + api + "?code=" + ComParameters.Parameters.devCode;
                    var result = Get(httpUri);
                    if (!string.IsNullOrEmpty(result) && result.Contains("\"code\""))
                    {
                        var jo = JObject.Parse(result);
                        string code = jo.Value<string>("code");
                        //记录节目日志
                        Log.MyLog.WriteLogFile(result, "ProgrammeList");
                        if (code != "200")
                        {
                            Log.MyLog.WriteLogFile("获取设备节目列表失败：" + jo.Value<string>("msg"));
                        }
                        else
                        {
                            var Jo = JObject.Parse(result);
                            List<ProgModel> itemList = Jo.Value<JArray>("data").ToObject<List<ProgModel>>();
                            bool flag = DownLoadScreenConfig(itemList, result);
                            if (flag)
                            {
                                ScreenConfigReceiveEvent?.Invoke();
                            }
                        }

                    }
                    else
                    {
                        Log.MyLog.WriteLogFile("获取设备节目列表失败：" + result);
                    }
                }
                catch (Exception ex)
                {

                    Log.MyLog.WriteLogFile("获取设备节目列表异常：" + ex.ToString());
                }

            });
            ac.Start();
        }
        /// <summary>
        /// 获取后台图片或视频资源地址
        /// </summary
        /// <returns></returns>
        public List<ScheduleModel> GetResource()
        {
            string outLinePath = AppDomain.CurrentDomain.BaseDirectory + "/OutlineFiles";
            if (!Directory.Exists(outLinePath + "/Main"))
            {
                return null;
            }
            else
            {
                if (File.Exists(outLinePath + "/Main/screenconfig.txt"))
                {
                    string rev = FileManage.ReadContext(outLinePath + "/Main/screenconfig.txt");
                    if (!string.IsNullOrEmpty(rev))
                    {
                        var Jo = JObject.Parse(rev);
                        string code = Jo.Value<string>("code");
                        if (code == "200")
                        {
                            List<ProgModel> itemList = Jo.Value<JArray>("data").ToObject<List<ProgModel>>();
                            var Schedule = itemList.Where(i => i.date == DateTime.Now.ToString("yyyy-MM-dd")).FirstOrDefault();
                            var ScheduleNoNetLast = itemList.Last();
                            if (Schedule != null)
                            {
                                return Schedule.schedule;

                            }else if(ScheduleNoNetLast != null)
                            {
                                return ScheduleNoNetLast.schedule;
                            }
                            else
                            {
                                return null;
                            }

                        }
                        else
                        {
                            return null;
                        }
                    }
                    else
                    {
                        return null;
                    }
                }
                else
                {
                    return null;
                }
            }
        }
        /// <summary>
        /// 获取天气
        /// </summary>
        /// <returns></returns>
        public WeatherViewModel GetEnvironmental(string city)
        {
            WeatherViewModel weather = new WeatherViewModel();
            try
            {
                string api = "/api/data/v1/web/getWeather";
                string httpUri = _httpUrl + api + "?city=" + city;
                var result = Get(httpUri);
                if (!string.IsNullOrEmpty(result))
                {
                    Dictionary<string, Object> dic = JsonConvert.DeserializeObject<Dictionary<string, Object>>(result);
                    if (!string.IsNullOrEmpty(dic["data"].ToString()) && dic["code"].ToString() == "200")
                    {
                        Dictionary<string, Object> dicdata = JsonConvert.DeserializeObject<Dictionary<string, Object>>(dic["data"].ToString());
                        weather.area = dicdata["area"].ToString();
                        weather.temperatureHigh = dicdata["temperatureHigh"].ToString();
                        weather.city = dicdata["city"].ToString();
                        weather.temperatureNow = dicdata["temperatureNow"].ToString();
                        weather.windPower = dicdata["windPower"].ToString();
                        weather.temperatureLow = dicdata["temperatureLow"].ToString();
                        weather.weather = dicdata["weather"].ToString();
                        weather.aqi = dicdata["aqi"].ToString();
                        weather.humidity = dicdata["humidity"].ToString();
                        weather.windDirection = dicdata["windDirection"].ToString();
                        weather.prov = dicdata["prov"].ToString();
                        weather.pm = dicdata["pm"].ToString();
                    }
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("天气获取失败：" + ex.ToString());
            }
            return weather;
        }
        bool done = false;
        private string outLinePath = AppDomain.CurrentDomain.BaseDirectory + "OutlineFiles";
        public bool DownLoadScreenConfig(List<ProgModel> ProgList, string configStr)
        {
            if (!done)
            {
                done = true;
                try
                {
                    foreach (var resource in ProgList)
                    {
                        if (resource == null || resource.schedule == null || resource.schedule.Count == 0)
                        {
                            continue;
                        }
                        foreach (var item in resource.schedule)
                        {
                            if (item != null && item.programs != null)
                            {
                                foreach (var itemprogram in item.programs)
                                {
                                    if (itemprogram.backgroundMaterial != null)
                                    {
                                        var localFileName = string.Empty;
                                        ProgDownLoadFile(ComParameters.Parameters.downloadUrl + itemprogram.backgroundMaterial, (Path.GetFileName(itemprogram.backgroundMaterial)), outLinePath);
                                    }
                                    if (itemprogram.components != null)
                                    {
                                        foreach (var itemcomponent in itemprogram.components)
                                        {
                                            if (itemcomponent.materials != null)
                                            {
                                                foreach (var material in itemcomponent.materials)
                                                {
                                                    if (string.IsNullOrEmpty(material.fileUrl))
                                                    {
                                                        continue;
                                                    }
                                                    ProgDownLoadFile(ComParameters.Parameters.downloadUrl + material.fileUrl, (Path.GetFileName(material.fileUrl)), outLinePath);
                                                }
                                            }
                                            if (itemcomponent.subComponents != null)
                                            {
                                                foreach (var subComponents in itemcomponent.subComponents)
                                                {
                                                    if (subComponents.materials != null)
                                                    {
                                                        foreach (var materials in subComponents.materials)
                                                        {
                                                            if (!string.IsNullOrEmpty(materials.fileUrl))
                                                            {
                                                                ProgDownLoadFile(ComParameters.Parameters.downloadUrl + materials.fileUrl, (Path.GetFileName(materials.fileUrl)), outLinePath);
                                                            }

                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }                                    
                                }
                            }
                        }
                    }
                    bool flag = Write(outLinePath + "/temp/screenconfig.txt", configStr);
                    if (flag)
                    {
                        DirectoryInfo di = new DirectoryInfo(outLinePath + "/Main");//正式包路径
                        DirectoryInfo di2 = new DirectoryInfo(outLinePath + "/temp");//更新包解压路径
                        MergeDirectory(di2, di, true);
                        done = false;
                        return true;
                    }
                    else
                    {
                        done = false;
                        return false;
                    }
                }
                catch (Exception ex)
                {

                    Log.MyLog.WriteLogFile("下载分屏节目异常：" + ex.ToString());
                    return false;
                }
                finally
                {
                    done = false;
                }
            }
            else
            {
                return false;
            }
        }
        private bool ProgDownLoadFile(string fileUrl, string localFileName, string folderPath)
        {
            try
            {
                bool finsh = true;
                var tempFolder = outLinePath + "/temp";
                var mainFolder = outLinePath + "/Main";
                if (!Directory.Exists(tempFolder))
                {
                    Directory.CreateDirectory(tempFolder);
                }
                if (!File.Exists(tempFolder + "/" + localFileName))
                {
                    if (!File.Exists(mainFolder + "/" + localFileName))
                    {
                        if (File.Exists(tempFolder + "/" + localFileName))
                        {
                            return true;
                        }
                        if (File.Exists(tempFolder + "/" + localFileName + ".temp"))
                            File.Delete(tempFolder + "/" + localFileName + ".temp");
                        using (Stream fileStream = new FileStream(tempFolder + "/" + localFileName + ".temp", FileMode.OpenOrCreate))
                        {
                            try
                            {
                                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(fileUrl);
                                request.AddRange(fileStream.Length);

                                HttpWebResponse respone = (HttpWebResponse)request.GetResponse();
                                using (Stream netStream = respone.GetResponseStream())
                                {
                                    long totalDownloadedByte = 0;
                                    byte[] read = new byte[1024];
                                    int realReadLen = netStream.Read(read, 0, read.Length);
                                    while (realReadLen > 0)
                                    {
                                        totalDownloadedByte = realReadLen + totalDownloadedByte;

                                        fileStream.Write(read, 0, realReadLen);
                                        realReadLen = netStream.Read(read, 0, read.Length);

                                        System.Windows.Forms.Application.DoEvents();
                                    }
                                    netStream.Close();
                                }

                                if (fileStream.Length != respone.ContentLength)
                                {

                                    Log.MyLog.WriteLogFile("文件未下载完毕" + "------" + fileStream.Length + "------" + respone.ContentLength);
                                    finsh = false;

                                }
                                fileStream.Close();

                                File.Move(tempFolder + "/" + localFileName + ".temp", tempFolder + "/" + localFileName);

                            }
                            catch (Exception ex)
                            {
                                fileStream.Close();
                                File.Delete(tempFolder + "/" + localFileName + ".temp");
                                return false;
                            }
                        }
                    }
                    else
                    {
                        File.Copy(mainFolder + "/" + localFileName, tempFolder + "/" + localFileName);
                    }
                }
                if (!finsh)
                {
                    File.Delete(tempFolder + "/" + localFileName);
                    ProgDownLoadFile(fileUrl, localFileName, folderPath);
                    return false;
;                }
                return true;
            }
            catch (Exception e)
            {
                Log.MyLog.WriteLogFile("文件未下载完毕:" + e.ToString());
                return false;
            }
        }
        public bool Write(string path, string configStr)
        {
            try
            {
                if (!Directory.Exists(outLinePath + "/temp"))
                {
                    Directory.CreateDirectory(outLinePath + "/temp");
                }
                FileStream fs = new FileStream(path, FileMode.Create);
                StreamWriter sw = new StreamWriter(fs);
                //开始写入
                sw.Write(configStr);
                //清空缓冲区
                sw.Flush();
                //关闭流
                sw.Close();
                fs.Close();
                return true;
            }
            catch (Exception)
            {

                return false;
            }
        }
        /// <summary>
        /// 拷贝目录内容,删除本身
        /// </summary>
        /// <param name="source">源目录</param>
        /// <param name="destination">目的目录</param>
        /// <param name="copySubDirs">是否拷贝子目录</param>
        public void MergeDirectory(DirectoryInfo source, DirectoryInfo destination, bool copySubDirs)
        {
            if (!destination.Exists)
            {
                destination.Create(); //目标目录若不存在就创建
            }
            if (!source.Exists)
            {
                source.Create(); //目标目录若不存在就创建
            }
            FileInfo[] sourceFiles = source.GetFiles();
            FileInfo[] destinationFiles = destination.GetFiles();
            foreach (var item in sourceFiles)
            {
                if (item.Extension.Contains("txt"))
                {
                    item.CopyTo(Path.Combine(destination.FullName, item.Name), true);
                }
                else if ((!File.Exists(Path.Combine(destination.FullName, item.Name))))
                {
                    CopyTo(item, Path.Combine(destination.FullName, item.Name));
                }
            }

            foreach (var item in destinationFiles)
            {
                if (!File.Exists(Path.Combine(source.FullName, item.Name)))
                {
                    try
                    {
                        item.Delete();
                    }
                    catch (Exception ex)
                    {

                        Log.MyLog.WriteLogFile("MergeDirectory：" + ex.ToString());
                    }
                }
            }
            DeleteDir(source.FullName, 1);
        }
        /// <summary>
        /// 获取文件MD5 哈希码
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public string GetMD5HashFromFile(string fileName)
        {
            try
            {
                FileStream file = new FileStream(fileName, FileMode.Open);
                System.Security.Cryptography.MD5 md5 = new System.Security.Cryptography.MD5CryptoServiceProvider();
                byte[] retVal = md5.ComputeHash(file);
                file.Close();

                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < retVal.Length; i++)
                {
                    sb.Append(retVal[i].ToString("x2"));
                }
                return sb.ToString();
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("GetMD5HashFromFile：" + ex.ToString());
                return "";
            }
        }
        private void CopyTo(FileInfo tempFile, string mainFilePath)
        {
            try
            {
                string fileTempMD5 = GetMD5HashFromFile(tempFile.FullName);
                tempFile.CopyTo(mainFilePath, true);
                string fileMainMD5 = GetMD5HashFromFile(mainFilePath);
                if (fileTempMD5 != fileMainMD5)
                {
                    File.Delete(mainFilePath);
                    CopyTo(tempFile, mainFilePath);
                }
                else
                {
                    File.Delete(tempFile.FullName);
                }
            }
            catch (Exception e)
            {
                Log.MyLog.WriteLogFile("CopyTo：" + e.ToString());
                if (File.Exists(mainFilePath))
                {
                    File.Delete(mainFilePath);
                }
                CopyTo(tempFile, mainFilePath);
            }
        }
        public void DeleteDir(string srcPath, int isSelf = 0)
        {
            try
            {
                if (!Directory.Exists(srcPath))
                {
                    return;
                }
                DirectoryInfo dir = new DirectoryInfo(srcPath);
                FileSystemInfo[] fileinfo = dir.GetFileSystemInfos();  //返回目录中所有文件和子目录
                foreach (FileSystemInfo i in fileinfo)
                {
                    try
                    {
                        if (i is DirectoryInfo)            //判断是否文件夹
                        {
                            DirectoryInfo subdir = new DirectoryInfo(i.FullName);
                            subdir.Delete(true);          //删除子目录和文件
                        }
                        else
                        {
                            //如果 使用了 streamreader 在删除前 必须先关闭流 ，否则无法删除 sr.close();
                            File.Delete(i.FullName);      //删除指定文件
                        }
                    }
                    catch (Exception)
                    {


                    }
                }
                if (isSelf == 1)
                {
                    dir.Delete();
                }
            }
            catch (Exception ex)
            {
                Log.MyLog.WriteLogFile("DeleteDir：" + ex.ToString());
            }
        }
        public void removeDelegate()
        {

            if (ScreenConfigReceiveEvent != null)
            {
                System.Delegate[] dels = ScreenConfigReceiveEvent.GetInvocationList();
                for (int i = 0; i < dels.Length; i++)
                {
                    ScreenConfigReceiveEvent -= dels[i] as ScreenConfigDelegate;
                }
            }
        }
        #endregion

    }
}