using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace PaintDotNet.Hardware
{
    /// <summary>
    /// 单位转换类
    /// 毫米数 ＝(像素/DPI)* 25.4
    /// 像素=(毫米数/25.4)*DPI
    /// </summary>
    public class ToolUnitConversion
    {
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="ImgPath">图片路径</param>
        /// <param name="DpiType">
        /// 1=获取显示器的 Dpi
        /// 2=获取图片的 Dpi
        /// </param>
        public ToolUnitConversion(string ImgPath, int DpiType)
        {
            this.DpiType = DpiType;
            this.ImgPath = ImgPath;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="Img">图片对象</param>
        /// <param name="DpiType">
        /// 1=获取显示器的 Dpi
        /// 2=获取图片的 Dpi
        /// </param>
        public ToolUnitConversion(Bitmap Img, int DpiType = 2)
        {
            this.DpiType = DpiType;
            this.Img = Img;
        }

        float dpiX = 0;
        float dpiY = 0;

        /// <summary>
        /// 1英寸的物理长度：2.54厘米，这里表示25.4毫米
        /// </summary>
        public readonly double singleLengthD = 25.4;

        /// <summary>
        /// 1英寸的物理长度：2.54厘米，这里表示25.4毫米
        /// </summary>
        public readonly decimal singleLengthM = 25.4m;

        /// <summary>
        /// Dpi 类型
        /// 1=获取显示器的 Dpi
        /// 2=获取图片的 Dpi
        /// </summary>
        private int DpiType = 1;

        /// <summary>
        /// 图片路径
        /// </summary>
        private string ImgPath = "";
        /// <summary>
        /// 图片对象
        /// </summary>
        private Bitmap Img = null;


        /// <summary>
        /// 判断是否传入了图片
        /// </summary>
        /// <returns></returns>
        public bool IsImg()
        {
            try
            {
                if (Img == null)
                {
                    Img = (Bitmap)Image.FromFile(ImgPath);
                }
                if (Img != null)
                {
                    return true;
                }
            }
            catch
            {


            }
            return false;
        }


        public float DpiX
        {
            get
            {
                if (dpiX == 0)
                {
                    if (DpiType == 2 && IsImg())
                    {
                        //获取图片的 Dpi
                        DpiX = Img.HorizontalResolution;
                        DpiY = Img.VerticalResolution;
                    }
                    else
                    {
                        //获取显示器的 Dpi
                        using (Graphics graphics = Graphics.FromHwnd(IntPtr.Zero))
                        {
                            DpiX = graphics.DpiX;
                            DpiY = graphics.DpiY;
                        }
                    }

                }
                return dpiX;
            }
            set { dpiX = value; }
        }
        public float DpiY
        {
            get
            {
                var d = DpiX;
                return dpiY;
            }
            set { dpiY = value; }
        }

        /// <summary>
        /// 毫米转像素
        /// 像素=(毫米数/25.4)*DPI
        /// </summary>
        /// <param name="mmLength">毫米</param>
        /// <param name="imageMultiple">图片物理倍数</param>
        /// <returns>PX</returns>
        public double MMToPX(double mmLength, int imageMultiple)
        {
            //像素=(毫米数/25.4)*DPI
            if (DpiY > DpiX)
            {
                return ((mmLength / singleLengthD) * DpiY) * imageMultiple;
            }
            else
            {
                return ((mmLength / singleLengthD) * DpiX) * imageMultiple;
            }
        }

        /// <summary>
        /// 像素转毫米
        /// </summary>
        /// <param name="pxLength">像素</param>
        /// <param name="imageMultiple">图片物理倍数</param>
        /// <returns>MM</returns>
        public double PXToMM(double pxLength, int imageMultiple)
        {
            //毫米数 ＝(像素 / DPI)*25.4
            if (DpiY > DpiX)
            {
                return ((pxLength / DpiY) * singleLengthD) / imageMultiple;
            }
            else
            {
                return ((pxLength / DpiX) * singleLengthD) / imageMultiple;
            }
        }
            /// <summary>
        /// 像素转毫米
        /// </summary>
        /// <param name="pxLength">像素</param>
        /// <param name="imageMultiple">图片物理倍数</param>
        /// <returns>MM</returns>
        public decimal PXToMM(decimal pxLength, int imageMultiple)
        {
            //毫米数 ＝(像素 / DPI)*25.4
            if (DpiY > DpiX)
            {
                return ((pxLength / (decimal)DpiY) * singleLengthM) / imageMultiple;
            }
            else
            {
                return ((pxLength / (decimal)DpiX) * singleLengthM) / imageMultiple;
            }
        }


        /// <summary>
        /// 毫米转像素
        /// 像素=(毫米数/25.4)*DPI
        /// </summary>
        /// <param name="mmLength">毫米</param>
        /// <param name="imageMultiple">图片物理倍数</param>
        /// <returns>PX</returns>
        public decimal MMToPX(decimal mmLength, int imageMultiple)
        {
            //像素=(毫米数/25.4)*DPI
            if (DpiY > DpiX)
            {
                return ((mmLength / singleLengthM) * (decimal)DpiY) * imageMultiple;
            }
            else
            {
                return ((mmLength / singleLengthM) * (decimal)DpiX) * imageMultiple;
            }
        }

    


        /// <summary>
        /// 像素平方转毫米平方
        /// </summary>
        /// <param name="pxLength">像素</param>
        /// <param name="imageMultiple">图片物理倍数</param>
        /// <returns>毫米平方</returns>
        public double AreaPXToMM(double pxLength, int imageMultiple)
        {
            //假设 宽是 1 高等于本身
            double w = 1;
            double h = pxLength;

            double Height = PXToMM(h, imageMultiple);//毫米  长
            double Width = PXToMM(w, imageMultiple);//毫米 宽

            return Height * Width;
        }

        /// <summary>
        /// 像素平方转毫米平方
        /// </summary>
        /// <param name="pxLength">像素</param>
        /// <param name="imageMultiple">图片物理倍数</param>
        /// <returns>毫米平方</returns>
        public decimal AreaPXToMM(decimal pxLength, int imageMultiple)
        {
            //假设 宽是 1 高等于本身
            decimal w = 1;
            decimal h = pxLength;

            decimal Height = PXToMM(h, imageMultiple);//毫米  长
            decimal Width = PXToMM(w, imageMultiple);//毫米 宽

            return Height * Width;
        }


        /// <summary>
        /// 毫米平方转像素平方
        /// </summary>
        /// <param name="mmLength">毫米</param>
        /// <param name="imageMultiple">图片物理倍数</param>
        /// <returns>像素平方</returns>
        public double AreaMMToPX(double mmLength, int imageMultiple)
        {
            //假设 宽是 1 高等于本身
            double w = 1;
            double h = mmLength;

            double Height = MMToPX(h, imageMultiple);//毫米  长
            double Width = MMToPX(w, imageMultiple);//毫米 宽

            return Height * Width;
        }

        /// <summary>
        /// 毫米平方转像素平方
        /// </summary>
        /// <param name="mmLength">毫米</param>
        /// <param name="imageMultiple">图片物理倍数</param>
        /// <returns>像素平方</returns>
        public decimal AreaMMToPX(decimal mmLength, int imageMultiple)
        {
            //假设 宽是 1 高等于本身
            decimal w = 1;
            decimal h = mmLength;

            decimal Height = MMToPX(h, imageMultiple);//毫米  长
            decimal Width = MMToPX(w, imageMultiple);//毫米 宽

            return Height * Width;
        }

    }
}