using System;
using System.Collections.Generic;
using UnityEngine;

namespace Thousandto.Launcher.ExternalLibs
{
    [Serializable]
    public struct RadiaBlurData
    {
        public float WaitTime;
        [Range(0.1f, 5f)]
        public float Strength;
        [Range(0.1f, 1.0f)]
        public float CenterX;
        [Range(0.1f, 1.0f)]
        public float CenterY;
        public float StartRange;
        public float EndRange;
        public float ChangeTime;
        public bool Pingpong;
    }

    //模糊脚本
    [ExecuteInEditMode]
    public class AnimRadiaBlur : MonoBehaviour
    {
        #region 私有变量
        [SerializeField]
        private List<RadiaBlurData> _dataList = new List<RadiaBlurData>();
        private float _timer = 0f;
        private int _curIndex = 0;
        private bool _isPlaying = false;

        private Vector2 _strengt = Vector2.zero;
        private Vector2 _center = Vector2.zero;
        private float _startRange = 0f;
        private float _endRange = 0f;
        private float _changeTime = 0f;
        private bool _pingpong = true;

        private float _currentTime = 0f;
        private static Material _radiaBlurMaterial = null;
        #endregion

        #region//继承基类
        private void OnEnable()
        {
            _dataList.Sort(DataSort);
            _curIndex = 0;
            _timer = 0f;
            _currentTime = 0f;
            if (_radiaBlurMaterial == null)
            {
                _radiaBlurMaterial = new Material(ShaderFactory.Find("Hidden/Ares/PostEffect/RadiaBlur"));
                _radiaBlurMaterial.EnableKeyword("_GONBEST_GRAPHIC_BLIT_ON");
                

            }
        }

        private void OnRenderImage(RenderTexture source, RenderTexture destination)
        {
            if (_radiaBlurMaterial != null && _isPlaying)
            {
                _radiaBlurMaterial.SetVector("_Center", _center);
                _radiaBlurMaterial.SetVector("_Strength", _strengt);
                Graphics.Blit(source, destination, _radiaBlurMaterial);
            }
            else
            {
                Graphics.Blit(source, destination);
            }
        }

        private void OnDestroy()
        {
            if (_radiaBlurMaterial != null)
            {
                GameObject.DestroyImmediate(_radiaBlurMaterial);
            }
            _radiaBlurMaterial = null;
        }

        private void Update()
        {
            if (_curIndex < _dataList.Count)
            {
                float oldTimer = _timer;
                _timer += Time.deltaTime;
                var data = _dataList[_curIndex];
                if (oldTimer <= data.WaitTime && _timer >= data.WaitTime)
                {
                    _isPlaying = true;
                    _strengt.Set(data.Strength, data.Strength);
                    _center.Set(data.CenterX, data.CenterY);
                    _startRange = data.StartRange;
                    _endRange = data.EndRange;
                    _changeTime = data.ChangeTime;
                    _pingpong = data.Pingpong;
                    ++_curIndex;
                    _currentTime = 0f;
                }
            }

            if(_isPlaying)
            {
                float strength = _strengt.x;
                if (_pingpong)
                {
                    if (_currentTime < _changeTime * 2)
                    {
                        _currentTime += Time.deltaTime;
                        if (_currentTime <= _changeTime)
                        {
                            strength = Mathf.Lerp(_startRange, _endRange, _currentTime / _changeTime);
                        }
                        else
                        {
                            strength = Mathf.Lerp(_endRange, _startRange, (_currentTime - _changeTime) / _changeTime);
                        }
                    }
                    else
                    {
                        _isPlaying = false;
                    }
                }
                else
                {
                    if (_currentTime < _changeTime)
                    {
                        _currentTime += Time.deltaTime;
                        strength = Mathf.Lerp(_startRange, _endRange, _currentTime / _changeTime);
                    }
                    else
                    {
                        _isPlaying = false;
                    }
                }
                _strengt.Set(strength, strength);
            }
        }
        #endregion

        #region//私有函数
        private int DataSort(RadiaBlurData left, RadiaBlurData right)
        {
            return left.WaitTime.CompareTo(right.WaitTime);
        }
        #endregion

        

   
    }
}