using UnityEngine;
using TowerDefense.Level;
using Core.Utilities;

namespace TowerDefense.UI.HUD
{
    /// <summary>
    /// States the placement tile can be in
    /// </summary>
    public enum PlacementTileState
    {
        Filled,
        Empty
    }

    /// <summary>
    /// Simple class to illustrate tile placement locations
    /// 主要功能是在场景内能够表示可以放置Tower的位置
    /// </summary>
    public class PlacementTile : MonoBehaviour
    {
        /// <summary>
        /// Material to use when this tile is empty
        /// </summary>
        public Material emptyMaterial;
        /// <summary>
        /// Material to use when this tile is filled
        /// </summary>
        public Material filledMaterial;
        /// <summary>
        /// The renderer whose material we're changing
        /// </summary>
        public Renderer tileRenderer;

        /// <summary>
        /// 等待购买的材质
        /// </summary>
        public Material waitBuyMat;

        /// <summary>
        /// 已开放的材质.
        /// </summary>
        public Material openMat;

        /// <summary>
        /// 塔位已被破坏的材质
        /// </summary>
        public Material destroyedMat;

        /// <summary>
        /// 可以放置的塔位
        /// </summary>
        public Renderer canPlaceRenderer;

        /// <summary>
        /// 可以放置的
        /// </summary>
        public Material canPlaceMat;
        public Material canNotPlaceMat;

        /// <summary>
        /// 放置在当前位置
        /// </summary>
        public Material selectMat;

        //public ParticleSystem myPS;//可以升级的特效

        public ParticleSystem myOpenPS;//购买后的特效
        public ParticleSystem myPutPS;//交换塔位置后的特效

        public GameObject myDragSelectPS;//推拽时候移动到当前塔的特效

        /// <summary>
        /// 所在的格子坐标
        /// </summary>
        public IntVector2 GridPosition { get; set; }

        /// <summary>
        /// Update the state of this placement tile
        /// </summary>
        public void SetState(PlacementTileState newState)
        {
            switch (newState)
            {
                case PlacementTileState.Filled:
                    if (tileRenderer != null && filledMaterial != null)
                    {
                        tileRenderer.sharedMaterial = filledMaterial;
                    }
                    break;
                case PlacementTileState.Empty:
                    if (tileRenderer != null && emptyMaterial != null)
                    {
                        tileRenderer.sharedMaterial = emptyMaterial;
                    }
                    break;
            }
        }

        // public void SetParticleSystem(bool isOn)
        // {
        //     if (isOn)
        //     {
        //         if (myPS.gameObject.activeSelf != isOn) myPS.gameObject.SetActive(isOn);
        //         myPS.Play();

        //     }
        //     else
        //     {
        //         myPS.Stop();
        //         if (myPS.gameObject.activeSelf != isOn) myPS.gameObject.SetActive(isOn);

        //     }
        // }

        // /// <summary>
        // /// 设置是否可以放置
        // /// </summary>
        // /// <param name="canPlace"></param>
        // public void CheckCanPlace(bool canPlace)
        // {
        //     if (canPlaceRenderer)
        //     {
        //         if (canPlaceRenderer.enabled != canPlace)
        //             canPlaceRenderer.enabled = canPlace;
        //         if (canPlace)
        //         {
        //             SetSelect(false);
        //         }
        //         else if (towerVSRenderer.enabled)
        //         {
        //             towerVSRenderer.enabled = false;
        //         }
        //     }

        // }

        // /// <summary>
        // /// 设置当前材质
        // /// </summary>
        // /// <param name="isSelect"></param>
        // /// <param name="isEmpty"></param>
        // public void SetSelect(bool isSelect)
        // {
        //     if (isSelect)
        //     {
        //         if (canPlaceRenderer.material != selectMat)
        //         {
        //             canPlaceRenderer.material = selectMat;
        //         }
        //         //激活绿色的底
        //     }
        //     else
        //     {
        //         if (canPlaceRenderer.material != canPlaceMat)
        //         {
        //             canPlaceRenderer.material = canPlaceMat;
        //         }
        //         if (towerVSRenderer.enabled)
        //             towerVSRenderer.enabled = false;
        //     }
        // }

        /// <summary>
        /// 是否放置塔
        /// </summary>
        /// <param name="isOn"></param>
        /// <param name="towerName"></param>
        public void SetRender(bool isOn, string towerName)
        {
            if (canPlaceRenderer.enabled != isOn)
            {
                canPlaceRenderer.enabled = isOn;
            }
            if (myDragSelectPS.activeSelf != isOn)
            {
                myDragSelectPS.SetActive(isOn);
            }
            // if (isOn)
            // {
            //     myDragSelectPS.Play();
            // }
            // else
            // {
            //     myDragSelectPS.Stop();
            // }

            if (isOn && towerName != "")
            {
                SetTowerVirtualshadow(towerName);
                EndlessWaveLineManager.instance.SetWaveLineShow(GridPosition.x, true);
            }
            else if (!isOn && towerVSRenderer.enabled)
            {
                towerVSRenderer.enabled = false;
                EndlessWaveLineManager.instance.SetWaveLineShow(GridPosition.x, false);
            }

        }

        public void SetWarning(bool isOn)
        {
            canPlaceRenderer.material = isOn ? canNotPlaceMat : canPlaceMat;
        }

        /// <summary>
        /// 塔的虚影
        /// </summary>
        public Renderer towerVSRenderer;

        /// <summary>
        /// 塔的虚影
        /// </summary>
        public Material towerVSMat;

        public Texture fire, wood, water;

        private Vector3 fireScale = new Vector3(1f, 1f, 1f);
        private Vector3 woodScale = new Vector3(0.8f, 1.12f, 1f);
        private Vector3 waterScale = new Vector3(1.55f, 1.35f, 1f);

        private Vector3 fireOffectp = new Vector3(-0.05f, 0f, 0.15f);
        private Vector3 woodOffectp = new Vector3(0.0f, 0f, 0.3f);
        private Vector3 waterOffectp = new Vector3(0.0f, 0f, 0.47f);

        public void SetTowerVirtualshadow(string towerName)
        {
            if (towerName.StartsWith("GrowUpTower"))
            {
                if (!towerVSRenderer.enabled) towerVSRenderer.enabled = true;

                //火元素
                towerVSMat.SetTexture(shaderPropertyName, fire);
                towerVSRenderer.transform.localScale = fireScale;
                towerVSRenderer.transform.localPosition = fireOffectp;

            }
            else if (towerName.StartsWith("BlinkTower"))
            {
                //木元素
                if (!towerVSRenderer.enabled) towerVSRenderer.enabled = true;

                towerVSMat.SetTexture(shaderPropertyName, wood);
                towerVSRenderer.transform.localScale = woodScale;
                towerVSRenderer.transform.localPosition = woodOffectp;

            }
            else if (towerName.StartsWith("CopyCatTower"))
            {
                //水元素
                if (!towerVSRenderer.enabled) towerVSRenderer.enabled = true;

                towerVSMat.SetTexture(shaderPropertyName, water);
                towerVSRenderer.transform.localScale = waterScale;
                towerVSRenderer.transform.localPosition = waterOffectp;
            }
        }
        string shaderPropertyName;

        /// <summary>
        /// Start is called on the frame when a script is enabled just before
        /// any of the Update methods is called the first time.
        /// </summary>
        void Start()
        {
            // shaderPropertyName = ShaderUtil.GetPropertyName(towerVSMat.shader, 0);
            shaderPropertyName = "_MainTex";
            //Debug.Log("获取到了Shader的名字" + shaderPropertyName);
            towerVSRenderer.enabled = false;
        }


        /// <summary>
        /// 根据传入的参数来设置当前Grid对应的显示信息
        /// WORK START: 从这个函数开始，替换相关的显示效果
        /// </summary>
        /// <param name="newtype"></param>
        public void SetTileType(PlacementGridType newtype)
        {
            switch (newtype)
            {
                case PlacementGridType.EGridWaitBuy:
                    if (tileRenderer != null && waitBuyMat != null)
                        tileRenderer.sharedMaterial = waitBuyMat;
                    break;
                case PlacementGridType.EGridOpen:
                    //Debug.Log("开了塔" + EndlessLevelManager.instanceExists);
                    if (EndlessLevelManager.instanceExists)
                    {
                        tileRenderer.enabled = false;
                    }
                    else
                    {
                        if (tileRenderer != null && openMat != null)
                            tileRenderer.sharedMaterial = openMat;
                    }

                    if (canPlaceRenderer.material == canNotPlaceMat)
                    {
                        SetWarning(false);
                    }
                    break;
                case PlacementGridType.EGridDestroyed:
                    if (tileRenderer != null && destroyedMat != null)
                        tileRenderer.sharedMaterial = destroyedMat;
                    break;
            }
        }

        public void BuyPs()
        {
            myOpenPS?.Play();
            AudioSourceManager.Ins.Play(AudioEnum.OpenTowerPlace);
            EndlessRandomTower.instance.CheckMoney();
        }

        public void PutPs()
        {
            myPutPS?.Play();
        }

    }
}