using System;
using Shared;
using HDL_ON;
using HDL_ON.UI.CSS;
using HDL_ON.DAL.Server;
using HDL_ON.UI;
using System.Threading;
using HDL_ON.Entity;

namespace HDL_ON
{
    /// <summary>
    /// ImageUtlis
    /// 图片下载处理
    /// </summary>
    public class ImageUtlis
    {
        /// <summary>
        /// 用户头像
        /// </summary>
        public const string HEADIMAGE = "HeadImage.png";

        #region ■ 变量声明___________________________
        /// <summary>
        /// 通用方法
        /// </summary>
        private static ImageUtlis m_Current = null;
        /// <summary>
        /// 通用方法
        /// </summary>
        public static ImageUtlis Current
        {
            get
            {
                if (m_Current == null)
                {
                    m_Current = new ImageUtlis();
                }
                return m_Current;
            }
        }
        #endregion

        #region 房间、场景 图片上传和下载
        /// <summary>
        /// 上传图片
        /// </summary>
        public string UploadImage(UploadImageObj uploadImageObj)
        {
            var requestJson = HttpUtil.GetSignRequestJson(uploadImageObj);
            var revertObj = HttpUtil.RequestHttpsPostFroHome(NewAPI.API_POST_UploadImage, requestJson);
            if(revertObj.Code == StateCode.SUCCESS)
            {
                if(revertObj.Data != null)
                {
                    return revertObj.Data.ToString();
                }
            }
            else
            {
                IMessageCommon.Current.ShowErrorInfoAlter(revertObj.Code);
            }
            return "";
        }

        /// <summary>
        /// 通过图片路径下载图片
        /// </summary>
        public byte[] GetImageDownloadUrl(string imageKey)
        {
            var requestJson = HttpUtil.GetSignRequestJson(new GetImageUrlObj()
            {
                imageKey = imageKey,
            });
            var revertObj = HttpUtil.RequestHttpsPostFroHome(NewAPI.API_POST_GetImageUrl, requestJson);
            if (revertObj.Code == StateCode.SUCCESS)
            {
                if (revertObj.Data != null)
                {
                    if (!string.IsNullOrEmpty(revertObj.Data.ToString()))
                    {
                        var url = revertObj.Data.ToString();
                        return HttpUtil.HttpsDownload(url);
                    }
                }
            }
            return null;
        }

        /// <summary>
        /// 2020-12-03
        /// 检测加载图片
        /// 该方法目前只适用于房间和场景的背景图片
        /// </summary>
        /// <param name="imageKey">图片路径、云端下载图片的标识key</param>
        /// <param name="imageView">需要显示图片的ImageView</param>
        /// <param name="ignoreCache">是否需要忽略缓存</param>
        public void LoadLocalOrNetworkImages(string imageKey, ImageView imageView, bool ignoreCache = false)
        {
            try
            {
                //1.本地默认图库图片，直接加载本地
                if (imageKey.Contains("Classification/Room/Roombg") || imageKey.Contains("Intelligence/Gallery/scenebg"))
                {
                    if (imageView != null)
                    {
                        imageView.ImageBytes = null;
                        imageView.ImagePath = imageKey;
                        Utlis.WriteLine("imageKey 加载本地图片成功");
                    }
                }
                else
                {
                    //2.自定义图片，检测是否本地缓存过，没有则云端下载然后缓存
                    if (!ignoreCache && FileUtils.Exists(imageKey))
                    {
                        //2.1 本地有缓存并且不忽略缓存，直接本地读取
                        if (imageView != null)
                        {
                            imageView.ImageBytes = FileUtils.ReadFile(imageKey);
                            Utlis.WriteLine("imageKey 加载自定义缓存图片成功");
                        }
                    }
                    else
                    {
                        //2.2 本地没缓存，开启线程云端下载然后缓存
                        System.Threading.Tasks.Task.Run(() =>
                        {
                            byte[] imageBytes = GetImageDownloadUrl(imageKey);
                            if (imageBytes != null)
                            {
                                FileUtils.WriteFileByBytes(imageKey, imageBytes);
                                //2.3 下载成功，显示并缓存本地
                                Application.RunOnMainThread(() =>
                                {
                                    if (imageView != null)
                                    {
                                        imageView.ImageBytes = imageBytes;
                                        Utlis.WriteLine("imageKey 加载云端下载图片成功");
                                    }
                                });
                            }
                            else
                            {
                                //2.4 下载是否，是否使用默认图片
                                Utlis.WriteLine("imageKey 加载云端图片失败");
                            }
                        });
                    }
                }
            }
            catch (Exception ex)
            {
                Utlis.WriteLine("imageKey 加载图片异常 catch");
            }
            finally
            {
            }
        }

        /// <summary>
        /// 2020-12-03
        /// 检测加载图片
        /// 该方法目前只适用于房间和场景的背景图片
        /// </summary>
        /// <param name="imageKey">图片路径、云端下载图片的标识key</param>
        /// <param name="frameLayout">需要显示图片的FrameLayout</param>
        /// <param name="ignoreCache">是否需要忽略缓存</param>
        public void LoadLocalOrNetworkImages(string imageKey, FrameLayout frameLayout, bool ignoreCache = false)
        {
            try
            {
                //1.本地默认图库图片，直接加载本地
                if (imageKey.Contains("Classification/Room/Roombg") || imageKey.Contains("Intelligence/Gallery/scenebg"))
                {
                    if (frameLayout != null)
                    {
                        //imageView.ImageBytes = null;
                        frameLayout.BackgroundImagePath = imageKey;
                        Utlis.WriteLine("imageKey 加载本地图片成功");
                    }
                }
                else
                {
                    //2.自定义图片，检测是否本地缓存过，没有则云端下载然后缓存
                    if (!ignoreCache && FileUtils.Exists(imageKey))
                    {
                        //2.1 本地有缓存并且不忽略缓存，直接本地读取
                        if (frameLayout != null)
                        {
                            frameLayout.BackgroundImagePath = imageKey;
                            Utlis.WriteLine("imageKey 加载自定义缓存图片成功");
                        }
                    }
                    else
                    {
                        //2.2 本地没缓存，开启线程云端下载然后缓存
                        System.Threading.Tasks.Task.Run(() =>
                        {
                            byte[] imageBytes = GetImageDownloadUrl(imageKey);
                            if (imageBytes != null)
                            {
                                FileUtils.WriteFileByBytes(imageKey, imageBytes);
                                //2.3 下载成功，显示并缓存本地
                                Application.RunOnMainThread(() =>
                                {
                                    if (frameLayout != null)
                                    {
                                        frameLayout.BackgroundImagePath = imageKey;
                                        Utlis.WriteLine("imageKey 加载云端下载图片成功");
                                    }
                                });
                            }
                            else
                            {
                                //2.4 下载是否，是否使用默认图片
                                Utlis.WriteLine("imageKey 加载云端图片失败");
                            }
                        });
                    }
                }
            }
            catch (Exception ex)
            {
                Utlis.WriteLine("imageKey 加载图片异常 catch");
            }
            finally
            {
            }
        }

        /// <summary>
		/// 获取拼接用户头像的ImageKey规则
		/// </summary>
		/// <returns></returns>
		public string GetHeadImageKey(string userId)
        {
            return "ON" + "_" + userId + "_" + HEADIMAGE;
        }

        /// <summary>
        /// 生成头像上传规则参数
        /// </summary>
        /// <returns></returns>
        public UploadImageObj GetHeadImageUploadKeyObj(string userId)
        {
            return new UploadImageObj()
            {
                prefix = "ON",
                uid = userId,
                fileName = HEADIMAGE,
            };
        }

        /// <summary>
        /// 下载用户头像
        /// </summary>
        /// <param name="userId"></param>
        /// <param name="ignoreCache">是否忽略缓存</param>
        /// <returns></returns>
        public byte[] DownHeadImage(string userId, bool ignoreCache = false)
        {
            try
            {
                var imageKey = GetHeadImageKey(userId);
                byte[] imageBytes;
                if (!ignoreCache && FileUtils.Exists(imageKey))
                {
                    //本地有缓存
                    imageBytes = FileUtils.ReadFile(imageKey);
                }
                else
                {
                    //云端下载
                    imageBytes = GetImageDownloadUrl(imageKey);
                    if(imageBytes != null)
                    {
                        //保存到本地
                        FileUtils.WriteFileByBytes(imageKey, imageBytes);
                    }
                   
                }
                return imageBytes;
            }
            catch
            {
                return null;
            }
        }

        #endregion
    }
}