using Common;
using ImgOutAPI.Models;
using SoEasy.Common;
using SoEasy.DB;
using SoEasy.Logic;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Web;
using System.Web.Caching;
using System.Web.Mvc;


namespace ImgOutAPI.Controllers
{
    public class ImageController : Controller
    {
        static Cache cache = HttpRuntime.Cache;
        CommonBL bl = CommonBL.CreateInstance();
        static object lockObj = new object();

        /// <summary>
        /// 获取图片
        /// </summary>
        /// <param name="imageID">图片ID</param>
        /// <param name="width">图片宽度</param>
        /// <param name="height">图片高度</param>
        /// <param name="addWater">是否添加水印true或1为是</param>
        /// <param name="waterFontSize">水印字号大小</param>
        /// <param name="waterText">水印内容</param>
        /// <returns>操作结果的json字符串</returns>
        [HttpPost]
        public string GetImage(string imageID, int width, int height, int addWater, int waterFontSize, string waterText)
        {
            OPResult opRes = Utility.CheckArgsNotNullOrEmpty("imageID", imageID);

            lock (lockObj)//不锁整个方法会导致生成的图片不一定能保存成功
            {
                if (opRes.State == Enums.OPState.Success)
                {
                    opRes.State = Enums.OPState.Fail;
                    string cacheKey = imageID + "|" + width + "|" + height + "|" + addWater + "|" + waterFontSize + "|" + waterText;

                    //判断缓存中是否存在
                    object o = cache.Get(cacheKey);
                    if (o != null)
                    {
                        opRes = (OPResult)o;
                    }
                    else
                    {
                        //最终图片的物理存放路径,定义在这里是为了放进缓存对象,本应该定义在if(model!=null){内的
                        string imagePhysicsPath = "";

                        ImageModel model = new ImageModel();
                        model.Id = imageID;

                        model = bl.SelectFirst(model, opRes, null);
                        if (model != null)
                        {
                            //用GUID做缓存图片的名称
                            string fileGuid = Guid.NewGuid().ToString() + Path.GetExtension(model.Url);

                            //最终图片对外可访问的URL
                            string imageAccessURL = Vars.DoMain + "/" + Path.Combine(VarsEx.CacheImageRootPath.Replace("~", ""), fileGuid).Replace(@"\", "/");

                            //最终图片的物理存放路径
                            imagePhysicsPath = System.Web.HttpContext.Current.Server.MapPath(Path.Combine(VarsEx.CacheImageRootPath, fileGuid).Replace(@"\", "/"));

                            //原始图片
                            string originalImage = Path.Combine(VarsEx.ImageSrcRootPath, model.Url.Replace("~/", "").Replace("/", @"\"));

                            if (System.IO.File.Exists(originalImage))
                            {
                                List<string> listTempFile = new List<string>();
                                //图片是否改变
                                bool changeImage = false;
                                if (width > 1 || height > 1 || (addWater == 1))
                                {
                                    if (addWater == 1 && waterFontSize > 0 && waterFontSize < 72 && !string.IsNullOrWhiteSpace(waterText))//加水印
                                    {
                                        //临时水印图片存放路径
                                        string waterTmpFileName = imagePhysicsPath.Replace(".", "w.");

                                        if (ImageHelper.AddWatermarkText(originalImage, waterTmpFileName, waterFontSize, waterText, opRes))
                                        {
                                            //将水印图片做为后续缩放的原图片
                                            originalImage = waterTmpFileName;
                                            listTempFile.Add(waterTmpFileName);
                                        }
                                        else
                                        {
                                            opRes.Data = "图片添加水印失败.";
                                            return opRes.ToJsonString();
                                        }

                                    }

                                    if (width > 0 && height > 0 && width < model.Width && height < model.Height)//缩放
                                    {
                                        //临时缩放图片存放路径
                                        string zoomTmpFileName = imagePhysicsPath.Replace(".", "r.");

                                        if (ImageHelper.CreateThumbnail(originalImage, zoomTmpFileName, width, height, opRes))
                                        {
                                            originalImage = zoomTmpFileName;
                                            listTempFile.Add(zoomTmpFileName);
                                        }
                                        else
                                        {
                                            opRes.Data = "图片缩放失败.";
                                            return opRes.ToJsonString();
                                        }
                                    }

                                    changeImage = true;
                                }

                                try
                                {
                                    System.IO.File.Copy(originalImage, imagePhysicsPath, true);//将生成的文件复制到缓存文件目录

                                    opRes.State = Enums.OPState.Success;
                                    opRes.Data = imageAccessURL;

                                    if (changeImage)//删除图片改变过程中产生的临时文件
                                    {
                                        foreach (string item in listTempFile)
                                        {
                                            System.IO.File.Delete(item);
                                        }
                                    }
                                }
                                catch (Exception ex)
                                {
                                    Utility.Logger.Error("复制生成的图片到缓存目录时发生异常:" + ex);
                                    opRes.State = Enums.OPState.Exception;
                                }

                            }
                            else
                            {
                                opRes.Data = "图片文件不存在";
                            }
                        }
                        else
                        {
                            opRes.Data = "图片信息不存在.";
                            Utility.Logger.Error("图片信息不存在,imageID=" + imageID);
                        }

                        CacheItemRemovedCallback onRemove = new CacheItemRemovedCallback(DeleteCacheFile);
                        OPResultCache cacheData = new OPResultCache { State = opRes.State, Data = opRes.Data, FilePhysicalFullPath = imagePhysicsPath };
                        cache.Insert(cacheKey, cacheData, null, Cache.NoAbsoluteExpiration, TimeSpan.FromMinutes(60), CacheItemPriority.High, onRemove);
                    }

                }
            }
            return JsonHelper.ToJsonString(opRes);

        }


        private void DeleteCacheFile(string key, Object value, CacheItemRemovedReason reason)
        {
            //删除实际生成的文件
            OPResultCache res = (OPResultCache)value;
            if (res.State == Enums.OPState.Success)
            {
                string cacheFileName = res.FilePhysicalFullPath;
                if (System.IO.File.Exists(cacheFileName))
                {
                    try
                    {
                        System.IO.File.Delete(cacheFileName);
                    }
                    catch (Exception ex)
                    {
                        Utility.Logger.Error("移除图片缓存时,删除生成的缓存图片" + cacheFileName + "发生异常:" + ex);
                    }
                }
            }

        }


        class OPResultCache : OPResult
        {
            /// <summary>
            /// 缓存文件的真实路径
            /// </summary>
            public string FilePhysicalFullPath { get; set; }

        }
    }
}