using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Web;

namespace EShang.Common
{
    /// <summary>
    /// 图片相关公共方法
    /// </summary>
    public static class ImageHelper
    {
        /// <summary>
        /// Image转Base64
        /// </summary>
        /// <param name="image"></param>
        /// <returns></returns>
        public static string ImageToBase64(Image image)
        {
            MemoryStream memoryStream = new MemoryStream();
            image.Save(memoryStream, ImageFormat.Png);
            byte[] inArray = memoryStream.ToArray();
            memoryStream.Close();
            return Convert.ToBase64String(inArray);
        }

        /// <summary>
        /// Image转byte[]
        /// </summary>
        /// <param name="image"></param>
        /// <returns></returns>
        public static byte[] ImageToBytes(Image image)
        {
            ImageFormat format = image.RawFormat;
            using (MemoryStream ms = new MemoryStream())
            {
                image.Save(ms, ImageFormat.Png);
                byte[] buffer = new byte[ms.Length];
                //Image.Save()会改变MemoryStream的Position，需要重新Seek到Begin
                ms.Seek(0, SeekOrigin.Begin);
                ms.Read(buffer, 0, buffer.Length);
                return buffer;
            }
        }

        public static Image Base64ToImage(string base64String)
        {
            byte[] imageBytes = Convert.FromBase64String(base64String);
            MemoryStream ms = new MemoryStream(imageBytes, 0, imageBytes.Length);
            ms.Write(imageBytes, 0, imageBytes.Length);
            System.Drawing.Image image = System.Drawing.Image.FromStream(ms, true);
            return image;
        }

        /// <summary>
        /// Byte[]转Image
        /// </summary>
        /// <param name="buffer"></param>
        /// <returns></returns>
        public static Image BytesToImage(this byte[] buffer)
        {
            MemoryStream ms = new MemoryStream(buffer);
            Image image = Image.FromStream(ms);
            return image;
        }

        public static Bitmap GetImageFromBase64(string base64string)
        {
            byte[] b = Convert.FromBase64String(base64string);
            MemoryStream ms = new MemoryStream(b);
            Bitmap bitmap = new Bitmap(ms);
            return bitmap;
        }


        /// <summary>
        /// Base64String转Bitmap
        /// </summary>
        /// <param name="base64Data"></param>
        /// <returns></returns>
        public static Bitmap Base64StringToBitmap(string base64String)
        {
            MemoryStream stream = new MemoryStream();
            try
            {
                //过滤特殊字符即可    
                string dummyData = base64String.Trim().Replace("%", "").Replace(",", "").Replace(" ", "+");
                if (dummyData.Length % 4 > 0)
                {
                    dummyData = dummyData.PadRight(dummyData.Length + 4 - dummyData.Length % 4, '=');
                }
                byte[] arr = Convert.FromBase64String(dummyData);
                stream = new MemoryStream(arr);
                return new Bitmap(stream); ;
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                stream.Close();
            }
        }

        /// <summary>
        /// Bitmap转Base64String
        /// </summary>
        /// <param name="bmp"></param>
        /// <returns></returns>
        public static string BitmapToBase64String(Bitmap bmp)
        {
            MemoryStream stream = null;
            try
            {
                stream = new MemoryStream();
                bmp.Save(stream, System.Drawing.Imaging.ImageFormat.Jpeg);
                byte[] arr = new byte[stream.Length];
                stream.Position = 0;
                stream.Read(arr, 0, (int)stream.Length);
                return Convert.ToBase64String(arr);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                stream.Close();
            }
        }

        /// <summary>
        /// 获取图片编码信息
        /// </summary>
        private static ImageCodecInfo GetEncoderInfo(ImageFormat format)
        {
            ImageCodecInfo[] encoders;
            encoders = ImageCodecInfo.GetImageEncoders();
            for (int j = 0; j < encoders.Length; ++j)
            {
                if (encoders[j].FormatID == format.Guid)
                {
                    return encoders[j];
                }
            }
            return null;
        }

        /// <summary>
        /// 压缩图片
        /// </summary>
        /// <param name="base64Data">原始图片</param>
        /// <param name="quality">质量压缩比</param>
        /// <param name="multiple">收缩倍数</param>
        /// <param name="outputBase64Data">输出图片</param>
        /// <returns></returns>
        public static bool CompressedImage(string base64Data, long quality, int multiple, out string outputBase64Data)
        {
            outputBase64Data = base64Data;
            try
            {
                // 获取图片信息
                using (Bitmap bitmap = Base64StringToBitmap(base64Data))
                {
                    ImageCodecInfo myImageCodecInfo = GetEncoderInfo(bitmap.RawFormat);
                    if (null == myImageCodecInfo)
                    {
                        return false;
                    }

                    // 压缩质量
                    System.Drawing.Imaging.Encoder myEncoder = System.Drawing.Imaging.Encoder.Quality;
                    EncoderParameters myEncoderParameters = new EncoderParameters(1);
                    EncoderParameter myEncoderParameter = new EncoderParameter(myEncoder, quality);
                    myEncoderParameters.Param[0] = myEncoderParameter;

                    // 按比例压缩
                    float _xWidth = bitmap.Width;
                    float _yWidth = bitmap.Height;
                    Bitmap newImage = new Bitmap((int)(_xWidth / multiple), (int)(_yWidth / multiple));
                    Graphics g = Graphics.FromImage(newImage);
                    // 可按需配置属性
                    //g.CompositingQuality = CompositingQuality.HighQuality;
                    //g.CompositingMode = CompositingMode.SourceCopy;
                    //g.InterpolationMode = InterpolationMode.HighQualityBicubic;
                    g.DrawImage(bitmap, 0, 0, (_xWidth / multiple), (_yWidth / multiple));
                    g.Dispose();

                    // 保存图片
                    outputBase64Data = BitmapToBase64String(newImage);
                    return true;
                }
            }
            catch (Exception ex)
            {
                return false;
            }
        }

    }
}