namespace Yw.WinFrmUI.HydroL2d
{
    /// <summary>
    /// 缓存辅助类
    /// </summary>
    internal class CacheHelper
    {
        /// <summary>
        /// HydroL2d
        /// </summary>
        public static Paras_HydroL2d HydroL2d
        {
            get { return HydroL2dParasHelper.HydroL2d; }
        }

        #region 连接节点

        /// <summary>
        /// 连接节点填充画刷
        /// </summary>
        public static Brush JunctionFillBrush
        {
            get
            {
                if (_junctionFillBrush == null)
                {
                    var fillColor = ColorTranslator.FromHtml(HydroL2d.Junction.Fill.Color);
                    _junctionFillBrush = new SolidBrush(fillColor);
                }
                return _junctionFillBrush;
            }
        }
        private static Brush _junctionFillBrush = null;

        /// <summary>
        /// 连接节点悬停填充画刷
        /// </summary>
        public static Brush JunctionHoveredFillBrush
        {
            get
            {
                if (_junctionHoveredFillBrush == null)
                {
                    var fillColor = ColorTranslator.FromHtml(HydroL2d.Junction.HoveredFill.Color);
                    _junctionHoveredFillBrush = new SolidBrush(fillColor);
                }
                return _junctionHoveredFillBrush;
            }
        }
        private static Brush _junctionHoveredFillBrush = null;

        /// <summary>
        /// 连接节点选择填充画刷
        /// </summary>
        public static Brush JunctionSelectedFillBrush
        {
            get
            {
                if (_junctionSelectedFillBrush == null)
                {
                    var fillColor = ColorTranslator.FromHtml(HydroL2d.Junction.SelectedFill.Color);
                    _junctionSelectedFillBrush = new SolidBrush(fillColor);
                }
                return _junctionSelectedFillBrush;
            }
        }
        private static Brush _junctionSelectedFillBrush = null;

        #endregion

        #region 水库

        /// <summary>
        /// 水库图片
        /// </summary>
        public static Image ReservoirImage
        {
            get
            {
                if (_reservoirImage == null)
                {
                    var fileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"images/l2d/{HydroL2d.Reservoir.Image}.png");
                    using (var img = Image.FromFile(fileName))
                    {
                        _reservoirImage = img.CloneC(HydroL2d.Reservoir.Size.Width, HydroL2d.Reservoir.Size.Height);
                        _reservoirImage.RotateFlip(RotateFlipType.RotateNoneFlipY);
                    }
                }
                return _reservoirImage;
            }
        }
        private static Image _reservoirImage = null;

        /// <summary>
        /// 水库悬停图片
        /// </summary>
        public static Image ReservoirHoveredImage
        {
            get
            {
                if (_reservoirHoveredImage == null)
                {
                    var fileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"images/l2d/{HydroL2d.Reservoir.HoveredImage}.png");
                    using (var img = Image.FromFile(fileName))
                    {
                        _reservoirHoveredImage = img.CloneC(HydroL2d.Reservoir.HoveredSize.Width, HydroL2d.Reservoir.HoveredSize.Height);
                        _reservoirHoveredImage.RotateFlip(RotateFlipType.RotateNoneFlipY);
                    }
                }
                return _reservoirHoveredImage;
            }
        }
        private static Image _reservoirHoveredImage = null;

        /// <summary>
        /// 水库选择图片
        /// </summary>
        public static Image ReservoirSelectedImage
        {
            get
            {
                if (_reservoirSelectedImage == null)
                {
                    var fileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"images/l2d/{HydroL2d.Reservoir.SelectedImage}.png");
                    using (var img = Image.FromFile(fileName))
                    {
                        _reservoirSelectedImage = img.CloneC(HydroL2d.Reservoir.SelectedSize.Width, HydroL2d.Reservoir.SelectedSize.Height);
                        _reservoirSelectedImage.RotateFlip(RotateFlipType.RotateNoneFlipY);
                    }
                }
                return _reservoirSelectedImage;
            }
        }
        private static Image _reservoirSelectedImage = null;

        #endregion

        #region 水池

        /// <summary>
        /// 水池图片
        /// </summary>
        public static Image TankImage
        {
            get
            {
                if (_tankImage == null)
                {
                    var fileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"images/l2d/{HydroL2d.Tank.Image}.png");
                    using (var img = Image.FromFile(fileName))
                    {
                        _tankImage = img.CloneC(HydroL2d.Tank.Size.Width, HydroL2d.Tank.Size.Height);
                        _tankImage.RotateFlip(RotateFlipType.RotateNoneFlipY);
                    }
                }
                return _tankImage;
            }
        }
        private static Image _tankImage = null;

        /// <summary>
        /// 水池悬停图片
        /// </summary>
        public static Image TankHoveredImage
        {
            get
            {
                if (_tankHoveredImage == null)
                {
                    var fileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"images/l2d/{HydroL2d.Tank.HoveredImage}.png");
                    using (var img = Image.FromFile(fileName))
                    {
                        _tankHoveredImage = img.CloneC(HydroL2d.Tank.HoveredSize.Width, HydroL2d.Tank.HoveredSize.Height);
                        _tankHoveredImage.RotateFlip(RotateFlipType.RotateNoneFlipY);
                    }
                }
                return _tankHoveredImage;
            }
        }
        private static Image _tankHoveredImage = null;

        /// <summary>
        /// 水池选择图片
        /// </summary>
        public static Image TankSelectedImage
        {
            get
            {
                if (_tankSelectedImage == null)
                {
                    var fileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"images/l2d/{HydroL2d.Tank.SelectedImage}.png");
                    using (var img = Image.FromFile(fileName))
                    {
                        _tankSelectedImage = img.CloneC(HydroL2d.Tank.SelectedSize.Width, HydroL2d.Tank.SelectedSize.Height);
                        _tankSelectedImage.RotateFlip(RotateFlipType.RotateNoneFlipY);
                    }
                }
                return _tankSelectedImage;
            }
        }
        private static Image _tankSelectedImage = null;

        #endregion

        #region 管线

        /// <summary>
        /// 管道线画笔
        /// </summary>
        public static Pen PipeLinePen
        {
            get
            {
                if (_pipeLinePen == null)
                {
                    var lineColor = ColorTranslator.FromHtml(HydroL2d.Pipe.Line.Color);
                    var lineWidth = HydroL2d.Pipe.Line.Width;
                    _pipeLinePen = new Pen(lineColor, lineWidth);
                }
                return _pipeLinePen;
            }
        }
        private static Pen _pipeLinePen = null;

        /// <summary>
        /// 管道悬停线画笔
        /// </summary>
        public static Pen PipeHoveredLinePen
        {
            get
            {
                if (_pipeHoveredLinePen == null)
                {
                    var lineColor = ColorTranslator.FromHtml(HydroL2d.Pipe.HoveredLine.Color);
                    var lineWidth = HydroL2d.Pipe.HoveredLine.Width;
                    _pipeHoveredLinePen = new Pen(lineColor, lineWidth);
                }
                return _pipeHoveredLinePen;
            }
        }
        private static Pen _pipeHoveredLinePen = null;

        /// <summary>
        /// 管道选择线画笔
        /// </summary>
        public static Pen PipeSelectedLinePen
        {
            get
            {
                if (_pipeSelectedLinePen == null)
                {
                    var lineColor = ColorTranslator.FromHtml(HydroL2d.Pipe.SelectedLine.Color);
                    var lineWidth = HydroL2d.Pipe.SelectedLine.Width;
                    _pipeSelectedLinePen = new Pen(lineColor, lineWidth);
                }
                return _pipeSelectedLinePen;
            }
        }
        private static Pen _pipeSelectedLinePen = null;

        #endregion

        #region 水泵

        /// <summary>
        /// 水泵线画笔
        /// </summary>
        public static Pen PumpLinePen
        {
            get
            {
                if (_pumpLinePen == null)
                {
                    var lineColor = ColorTranslator.FromHtml(HydroL2d.Pump.Line.Color);
                    var lineWidth = HydroL2d.Pump.Line.Width;
                    _pumpLinePen = new Pen(lineColor, lineWidth);
                }
                return _pumpLinePen;
            }
        }
        private static Pen _pumpLinePen = null;

        /// <summary>
        /// 水泵图片
        /// </summary>
        public static Image PumpImage
        {
            get
            {
                if (_pumpImage == null)
                {
                    var fileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"images/l2d/{HydroL2d.Pump.Image}.png");
                    using (var img = Image.FromFile(fileName))
                    {
                        _pumpImage = img.CloneC(HydroL2d.Pump.Size.Width, HydroL2d.Pump.Size.Height);
                        _pumpImage.RotateFlip(RotateFlipType.RotateNoneFlipY);
                    }
                }
                return _pumpImage;
            }
        }
        private static Image _pumpImage = null;

        /// <summary>
        /// 水泵选择线画笔
        /// </summary>
        public static Pen PumpSelectedLinePen
        {
            get
            {
                if (_pumpSelectedLinePen == null)
                {
                    var lineColor = ColorTranslator.FromHtml(HydroL2d.Pump.SelectedLine.Color);
                    var lineWidth = HydroL2d.Pump.SelectedLine.Width;
                    _pumpSelectedLinePen = new Pen(lineColor, lineWidth);
                }
                return _pumpSelectedLinePen;
            }
        }
        private static Pen _pumpSelectedLinePen = null;

        /// <summary>
        /// 水泵选择图片
        /// </summary>
        public static Image PumpSelectedImage
        {
            get
            {
                if (_pumpSelectedImage == null)
                {
                    var fileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"images/l2d/{HydroL2d.Pump.SelectedImage}.png");
                    using (var img = Image.FromFile(fileName))
                    {
                        _pumpSelectedImage = img.CloneC(HydroL2d.Pump.SelectedSize.Width, HydroL2d.Pump.SelectedSize.Height);
                        _pumpSelectedImage.RotateFlip(RotateFlipType.RotateNoneFlipY);
                    }
                }
                return _pumpSelectedImage;
            }
        }
        private static Image _pumpSelectedImage = null;

        /// <summary>
        /// 水泵悬停线画笔
        /// </summary>
        public static Pen PumpHoveredLinePen
        {
            get
            {
                if (_pumpHoveredLinePen == null)
                {
                    var lineColor = ColorTranslator.FromHtml(HydroL2d.Pump.HoveredLine.Color);
                    var lineWidth = HydroL2d.Pump.HoveredLine.Width;
                    _pumpHoveredLinePen = new Pen(lineColor, lineWidth);
                }
                return _pumpHoveredLinePen;
            }
        }
        private static Pen _pumpHoveredLinePen = null;

        /// <summary>
        /// 水泵悬停图片
        /// </summary>
        public static Image PumpHoveredImage
        {
            get
            {
                if (_pumpHoveredImage == null)
                {
                    var fileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"images/l2d/{HydroL2d.Pump.HoveredImage}.png");
                    using (var img = Image.FromFile(fileName))
                    {
                        _pumpHoveredImage = img.CloneC(HydroL2d.Pump.HoveredSize.Width, HydroL2d.Pump.HoveredSize.Height);
                        _pumpHoveredImage.RotateFlip(RotateFlipType.RotateNoneFlipY);
                    }
                }
                return _pumpHoveredImage;
            }
        }
        private static Image _pumpHoveredImage = null;

        #endregion

        #region 阀门

        /// <summary>
        /// 阀门线画笔
        /// </summary>
        public static Pen ValveLinePen
        {
            get
            {
                if (_valveLinePen == null)
                {
                    var lineColor = ColorTranslator.FromHtml(HydroL2d.Valve.Line.Color);
                    var lineWidth = HydroL2d.Valve.Line.Width;
                    _valveLinePen = new Pen(lineColor, lineWidth);
                }
                return _valveLinePen;
            }
        }
        private static Pen _valveLinePen = null;

        /// <summary>
        /// 阀门图片
        /// </summary>
        public static Image ValveImage
        {
            get
            {
                if (_valveImage == null)
                {
                    var fileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"images/l2d/{HydroL2d.Valve.Image}.png");
                    using (var img = Image.FromFile(fileName))
                    {
                        _valveImage = img.CloneC(HydroL2d.Valve.Size.Width, HydroL2d.Valve.Size.Height);
                        _valveImage.RotateFlip(RotateFlipType.RotateNoneFlipY);
                    }
                }
                return _valveImage;
            }
        }
        private static Image _valveImage = null;

        /// <summary>
        /// 阀门选择线画笔
        /// </summary>
        public static Pen ValveSelectedLinePen
        {
            get
            {
                if (_valveSelectedLinePen == null)
                {
                    var lineColor = ColorTranslator.FromHtml(HydroL2d.Valve.SelectedLine.Color);
                    var lineWidth = HydroL2d.Valve.SelectedLine.Width;
                    _valveSelectedLinePen = new Pen(lineColor, lineWidth);
                }
                return _valveSelectedLinePen;
            }
        }
        private static Pen _valveSelectedLinePen = null;

        /// <summary>
        /// 阀门选择图片
        /// </summary>
        public static Image ValveSelectedImage
        {
            get
            {
                if (_valveSelectedImage == null)
                {
                    var fileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"images/l2d/{HydroL2d.Valve.SelectedImage}.png");
                    using (var img = Image.FromFile(fileName))
                    {
                        _valveSelectedImage = img.CloneC(HydroL2d.Valve.SelectedSize.Width, HydroL2d.Valve.SelectedSize.Height);
                        _valveSelectedImage.RotateFlip(RotateFlipType.RotateNoneFlipY);
                    }
                }
                return _valveSelectedImage;
            }
        }
        private static Image _valveSelectedImage = null;

        /// <summary>
        /// 阀门悬停线画笔
        /// </summary>
        public static Pen ValveHoveredLinePen
        {
            get
            {
                if (_valveHoveredLinePen == null)
                {
                    var lineColor = ColorTranslator.FromHtml(HydroL2d.Valve.HoveredLine.Color);
                    var lineWidth = HydroL2d.Valve.HoveredLine.Width;
                    _valveHoveredLinePen = new Pen(lineColor, lineWidth);
                }
                return _valveHoveredLinePen;
            }
        }
        private static Pen _valveHoveredLinePen = null;

        /// <summary>
        /// 阀门悬停图片
        /// </summary>
        public static Image ValveHoveredImage
        {
            get
            {
                if (_valveHoveredImage == null)
                {
                    var fileName = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, $"images/l2d/{HydroL2d.Valve.HoveredImage}.png");
                    using (var img = Image.FromFile(fileName))
                    {
                        _valveHoveredImage = img.CloneC(HydroL2d.Valve.HoveredSize.Width, HydroL2d.Valve.HoveredSize.Height);
                        _valveHoveredImage.RotateFlip(RotateFlipType.RotateNoneFlipY);
                    }
                }
                return _valveHoveredImage;
            }
        }
        private static Image _valveHoveredImage = null;

        #endregion


    }
}