namespace Yw.WinFrmUI.HydroL2d
{
    /// <summary>   
    /// 动画功能图片处理类
    /// 使用方法
    /// 用Image对象实例化，注册OnFrameChanged事件，在事件中处理图片当前帧改变需要做的事，注意调用Image需要lock，否则容易报错
    /// </summary>   
    internal class AnimateImage : IDisposable
    {
        /// <summary>
        /// 原始图片
        /// </summary>
        public Image Image
        {
            get { return _img; }
        }
        private Image _img = null;

        /// <summary>   
        /// 能否动画   
        /// </summary>   
        public bool CanAnimate
        {
            get { return _canAnimate; }
        }
        private bool _canAnimate = false;

        /// <summary>   
        /// 总帧数。   
        /// </summary>   
        public int FrameCount
        {
            get { return _frameCount; }
        }
        private int _frameCount = 1;

        /// <summary>   
        /// 播放的当前帧。   
        /// </summary>   
        public int CurrentFrame
        {
            get { return _currentFrame; }
        }
        private int _currentFrame = 0;

        private FrameDimension _frameDimension;







        /// <summary>   
        /// 动画当前帧发生改变时触发。   
        /// </summary>   
        public event EventHandler<EventArgs> OnFrameChanged;

        /// <summary>   
        /// 实例化一个AnimateImage。   
        /// </summary>   
        /// <param name="img">动画图片</param>   
        public AnimateImage(Image img)
        {
            _img = img;
            lock (_img)
            {
                _canAnimate = ImageAnimator.CanAnimate(_img);
                if (_canAnimate)
                {
                    Guid[] guid = _img.FrameDimensionsList;
                    _frameDimension = new FrameDimension(guid[0]);
                    _frameCount = _img.GetFrameCount(_frameDimension);
                }
            }
        }

        /// <summary>   
        /// 播放这个动画。   
        /// </summary>   
        public void Play()
        {
            if (_canAnimate)
            {
                lock (_img)
                {
                    ImageAnimator.Animate(_img, new EventHandler(FrameChanged));
                }
            }
        }

        /// <summary>   
        /// 停止播放。   
        /// </summary>   
        public void Stop()
        {
            if (_canAnimate)
            {
                lock (_img)
                {
                    ImageAnimator.StopAnimate(_img, new EventHandler(FrameChanged));
                }
            }
        }

        /// <summary>   
        /// 重置动画，使之停止在第0帧位置上。   
        /// </summary>   
        public void Reset()
        {
            if (_canAnimate)
            {
                try
                {
                    ImageAnimator.StopAnimate(_img, new EventHandler(FrameChanged));
                    lock (_img)
                    {
                        _img.SelectActiveFrame(_frameDimension, 0);
                        _currentFrame = 0;
                    }
                }
                catch
                {
                    return;
                }

            }
        }

        private void FrameChanged(object sender, EventArgs e)
        {
            _currentFrame = _currentFrame + 1 >= _frameCount ? 0 : _currentFrame + 1;
            try
            {
                lock (_img)
                {
                    var ci = _img.GetFrameCount(_frameDimension);
                    if (ci < _currentFrame)
                        return;

                    _img.SelectActiveFrame(_frameDimension, _currentFrame);
                }
                if (OnFrameChanged != null)
                {
                    OnFrameChanged(_img, e);
                }
            }
            catch
            {
                return;
            }
        }


        /// <summary>
        /// 释放图片资源
        /// </summary>
        public void Dispose()
        {
            if (this.Image != null)
            {
                this.Image.Dispose();
            }
        }



    }
}