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

namespace Thousandto.Launcher.ExternalLibs
{
    /// <summary>
    /// 渲染的资源信息
    /// </summary>
    [Serializable]
    public class RenderAssetData
    {
        //路径
        public string Path;
        //渲染的类型
        public RendererType RenderType;
        //关联Mesh数组
        public Mesh[] MeshArray;                
        //材质索引
        public MaterialAssetData[] MatArray;
        //这个时针对粒子效果的,如果有拖尾材质,需要这个设定一个值
        public int TrailMaterialIndex = -1;
        //处理特效Renderer中拖尾材质
        public MaterialAssetData TrailMaterialAsset = null;

        #region //运行时执行
        //卸载
        public void Unload()
        {
            
            if (MeshArray != null)
            {
                for (int i = 0; i < MeshArray.Length; i++)
                {
                    if (MeshArray[i] != null)
                    {
                        Resources.UnloadAsset(MeshArray[i]);
                    }
                }
                MeshArray = null;
            }

            if (MatArray != null)
            {
                for (int i = 0; i < MatArray.Length; i++)
                {
                    if (MatArray[i] != null)
                    {
                        MatArray[i].Unload();
                    }
                }
                MatArray = null;
            }
        }

        //设置Renderer
        public void ToRenderer(Transform trans)
        {
            Material[] mats = null;
            if (MatArray != null)
            {
                mats = new Material[MatArray.Length];
                for (int i = 0; i < MatArray.Length; i++)
                {
                    if (MatArray[i] != null)
                    {
                        mats[i] = MatArray[i].ToMaterialAsset();
                    }
                }
            }
            Material trailMat = null;
            if (TrailMaterialAsset != null && !string.IsNullOrEmpty(TrailMaterialAsset.ShaderName))
            {
                trailMat = TrailMaterialAsset.ToMaterialAsset();
            }
            else if(TrailMaterialIndex >= 0 && TrailMaterialIndex < mats.Length)
            {
                trailMat = mats[TrailMaterialIndex]; 
            }
            switch (RenderType)
            {
                case RendererType.MeshRenderer: //静态Mesh
                    var mf = trans.GetComponent<MeshFilter>();
                    if (mf != null) mf.sharedMesh = (MeshArray != null && MeshArray.Length > 0) ? MeshArray[0] : null; 
                    var mr = trans.GetComponent<MeshRenderer>();
                    if (mr != null) mr.sharedMaterials = mats;
                    break;
                case RendererType.SkinnedMeshRenderer://骨骼皮肤Mesh
                    var smr = trans.GetComponent<SkinnedMeshRenderer>();
                    if (smr != null)
                    {
                        smr.sharedMesh = (MeshArray != null && MeshArray.Length > 0) ? MeshArray[0] : null;
                        smr.sharedMaterials = mats;
                    }
                    break;
                case RendererType.ParticleSystemRenderer://粒子Mesh
                    var psr = trans.GetComponent<ParticleSystemRenderer>();
                    if (psr != null)
                    {
                        psr.sharedMaterials = mats;
                        if (trailMat != null)
                        {
                            psr.trailMaterial = trailMat;
                        }
                        psr.SetMeshes(MeshArray);

                    }
                    break;
                case RendererType.TrailRenderer:
                    var tr = trans.GetComponent<TrailRenderer>();
                    if (tr != null)
                    {
                        tr.sharedMaterials = mats;
                    }
                    break;              
                    
            }
            
        }
        #endregion

        #region//编辑器时执行--打包之前数据准备用
#if UNITY_EDITOR
        [NonSerialized]
        public Transform TheTransform;
        //从Renderer获取信息
        public bool FromRenderer(Renderer rd, bool removeFromRender,bool isUseTexName, string texDir)
        {
            Material[] mats = null;
            Material trailMat = null;

            if (rd is SkinnedMeshRenderer)
            {//带有骨骼的Renderer
                RenderType = RendererType.SkinnedMeshRenderer;
                var skinnedRender = rd as SkinnedMeshRenderer;
                mats = skinnedRender.sharedMaterials;
                MeshArray = new Mesh[] { skinnedRender.sharedMesh };
                if (removeFromRender)
                {
                    skinnedRender.sharedMaterials = new Material[0];
                    skinnedRender.sharedMesh = null;
                }
            }
            else if (rd is MeshRenderer)
            {//静态Mesh的Renderer
                var render = rd as MeshRenderer;
                RenderType = RendererType.MeshRenderer;
                mats = render.sharedMaterials;
                var mf = rd.gameObject.GetComponent<MeshFilter>();
                if (mf != null)
                {
                    MeshArray = new Mesh[] { mf.sharedMesh };
                }

                if (removeFromRender)
                {
                    render.sharedMaterials = new Material[0];
                    if (mf != null)
                    {
                        mf.sharedMesh = null;
                    }
                }
            }
            else if (rd is ParticleSystemRenderer)
            {//粒子系统的Renderer
                var psr = rd as ParticleSystemRenderer;
                RenderType = RendererType.ParticleSystemRenderer;
                mats = psr.sharedMaterials;
                trailMat = psr.trailMaterial;
                MeshArray = new Mesh[psr.meshCount];
                int ret = psr.GetMeshes(MeshArray);
                Debug.Log("MeshCount:" + psr.meshCount + " " + ret + " " + psr.mesh);
                if (removeFromRender)
                {   
                    psr.sharedMaterials = new Material[0];
                    psr.trailMaterial = null;
                    psr.SetMeshes(new Mesh[0]);
                }

                TrailMaterialIndex = -1;
                if (trailMat != null)
                {
                    for (int i = 0; i < mats.Length; i++)
                    {
                        if (mats[i] == trailMat)
                        {
                            TrailMaterialIndex = i;
                            break;
                        }
                    }
                    if (TrailMaterialIndex >= 0)
                    {//说明拖尾材质,在材质数组中.那么就不需要单独存储拖尾材质 ,只需要记录索引就可以了
                        trailMat = null;
                    }
                }
                
            }
            else if (rd is TrailRenderer)
            {
                var tr = rd as TrailRenderer;
                RenderType = RendererType.TrailRenderer;
                mats = tr.sharedMaterials;
                if (removeFromRender)
                {
                    tr.sharedMaterials = new Material[0];
                    tr.sharedMaterial = null;
                }
            }
            else
            {//未知
                RenderType = RendererType.None;
                Debug.Log("Find Unknow Render:" + rd.GetType().FullName);
            }
            //材质列表是否为空
            if (mats != null)
            {
                List<MaterialAssetData> list = new List<MaterialAssetData>();
                for (int i = 0; i < mats.Length; i++)
                {
                    if (mats[i] != null)
                    {
                        MaterialAssetData mi = new MaterialAssetData();
                        mi.FormMaterialAsset(mats[i], isUseTexName,texDir);
                        list.Add(mi);
                    }
                }
             
                MatArray = list.ToArray();
            }

            //处理特效中的拖尾材质
            if (trailMat != null)
            {
                TrailMaterialAsset = new MaterialAssetData();
                TrailMaterialAsset.FormMaterialAsset(trailMat, isUseTexName, texDir);
            }
            return RenderType != RendererType.None;
        }
#endif
        #endregion

        #region//子类枚举
        //Render类型
        public enum RendererType
        {
            None,
            //Mesh渲染
            MeshRenderer,  
            //SkinnedMesh渲染
            SkinnedMeshRenderer,
            //粒子渲染
            ParticleSystemRenderer,
            //Trail渲染
            TrailRenderer

        }
        #endregion

    }
}