using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.UI;

/// <summary>
/// 透明脚本
/// </summary>
public class TransparentGlow : MonoBehaviour
{
    public bool isTransparentGlow = false;

    [HideInInspector] public List<MeshRenderer> meshRenderers;
    /// <summary>
    /// 自身的
    /// </summary>
    [HideInInspector] public List<Material> materials;
    /// <summary>
    /// 复制出来的
    /// </summary>
    public List<Material> empty = new List<Material>();

    public Shader TransparentGlow_Shader;
    public Shader TransparentGlow_Shader_half;

    public List<MeshRenderer> MeshRenderers
    {
        get
        {
            if (meshRenderers == null)
                meshRenderers = GetComponentsInChildren<MeshRenderer>().ToList();
            return meshRenderers;
        }
    }

    public List<Material> Materials
    {
        get
        {
            if (materials == null)
            {
                materials = new List<Material>();
                MeshRenderers.ForEach(render =>
                {
                    Array.ForEach(render.materials, (_mat) =>
                    {
                        if (!materials.Contains(_mat))
                        {
                            materials.Add(_mat);
                            Material _emp = new Material(_mat);
                            empty.Add(_emp);
                        }
                    });
                });
            }
            return materials;
        }
    }

    /// <summary>
    /// 原始机柜模型
    /// </summary>
    private List<Material> original_jigui = new List<Material>();
    /// <summary>
    /// 原始设备模型
    /// </summary>
    private List<Material> original_shebei = new List<Material>();

    private List<Material> _jigui;
    private List<Material> _shebei;
    private bool search_u_wei, is_jigui;

    /// <summary>
    /// 若脚本在机柜上，则该字段为机柜材质
    /// 若脚本在设备上，则该字段为此设备材质
    /// </summary>
    public List<Material> jigui_mats
    {
        get
        {
            if (_jigui == null)
            {
                _jigui = new List<Material>();

                if (GetComponent<MeshRenderer>())
                {
                    Array.ForEach(GetComponent<MeshRenderer>().materials, m =>
                    {
                        if (!_jigui.Contains(m))
                        {
                            _jigui.Add(m);
                            original_jigui.Add(new Material(m));
                        }
                    });
                }

                for (int i = 0; i < transform.childCount; i++)
                {
                    if (transform.GetChild(i).GetComponent<MeshRenderer>())
                        Array.ForEach(transform.GetChild(i).GetComponent<MeshRenderer>().materials, m =>
                        {
                            if (!_jigui.Contains(m))
                            {
                                _jigui.Add(m);
                                original_jigui.Add(new Material(m));
                            }
                        });
                }


                //MeshRenderers.ForEach(render =>
                //{
                //    Array.ForEach(render.materials, (_mat) =>
                //    {
                //        if (!materials.Contains(_mat))
                //        {
                //            materials.Add(_mat);
                //            Material _emp = new Material(_mat);
                //            empty.Add(_emp);
                //        }
                //    });
                //});
            }
            return _jigui;
            //return materials;
        }
    }
    /// <summary>
    /// 若脚本在机柜上，则该字段有值且为所有设备材质；
    /// 若脚本在设备上，则该字段为空值
    /// </summary>
    public List<Material> shebei_mats
    {
        get
        {
            if (search_u_wei)
            {

            }
            else
            {
                _shebei = new List<Material>();
                search_u_wei = true;
                if (transform.Find("U位"))
                {
                    is_jigui = true;
                    Array.ForEach(transform.Find("U位").GetComponentsInChildren<MeshRenderer>(), mr =>
                    {
                        Array.ForEach(mr.materials, m =>
                        {
                            if (!_shebei.Contains(m))
                            {
                                _shebei.Add(m);
                                original_shebei.Add(new Material(m));
                            }
                        });
                    });
                }
                else
                {
                    is_jigui = false;
                }
            }
            return _shebei;
        }
    }


    // Start is called before the first frame update
    void Start()
    {
        //for (int i = 0; i < Materials.Count; i++)
        //    break;
        if (TransparentGlow_Shader == null)
            TransparentGlow_Shader = Resources.Load<Shader>("TransparentGlow");
        if (TransparentGlow_Shader_half == null)
            TransparentGlow_Shader_half = Resources.Load<Shader>("TransparentGlow_half");
    }

    // Update is called once per frame
    void Update()
    {

    }

    /// <summary>
    /// 场景刷新后，重新加载U位下的设备材质
    /// </summary>
    public void OnSceneReloaded()
    {
        search_u_wei = false;
    }

    /// <summary>
    /// 透明
    /// </summary>
    [ContextMenu("透明")]
    public void F1(/*float a = 0.5f*/)
    {
        //for (int i = 0; i < Materials.Count; i++)
        //{
        //    Materials[i].shader = TransparentGlow_Shader;
        //    Materials[i].renderQueue = 3000;
        //    Materials[i].SetFloat("_Transparecy", a);
        //}

        for (int i = 0; i < jigui_mats.Count; i++)
        {
            jigui_mats[i].shader = TransparentGlow_Shader;
            jigui_mats[i].renderQueue = 3000;
            //jigui_mats[i].SetFloat("_Transparecy", is_jigui ? a : a / 2);
        }

        for (int i = 0; i < shebei_mats.Count; i++)
        {
            shebei_mats[i].shader = TransparentGlow_Shader_half;
            shebei_mats[i].renderQueue = 3000;
            //shebei_mats[i].SetFloat("_Transparecy", a / 2);   
        }
        isTransparentGlow = true;
    }

    /// <summary>
    /// 恢复原材质
    /// </summary>
    [ContextMenu("恢复原材质")]
    public void F2()
    {
        //for (int i = 0; i < Materials.Count; i++)
        //{
        //    Materials[i].shader = empty[i].shader;
        //}

        for (int i = 0; i < jigui_mats.Count; i++)
        {
            jigui_mats[i].shader = original_jigui[i].shader;
        }

        for (int i = 0; i < shebei_mats.Count; i++)
        {
            shebei_mats[i].shader = original_shebei[i].shader;
        }
        isTransparentGlow = false;
    }

    [ContextMenu("添加点击组件")]
    public void F3()
    {
        TransparentGlow[] components = FindObjectsOfType<TransparentGlow>(false);

        foreach (var item in components)
        {
            ClickEvent clickEvent = item.GetComponent<ClickEvent>();
            BoxCollider boxCollider = item.GetComponent<BoxCollider>();
            if (item.gameObject.activeSelf)
            {
                if (!clickEvent) item.gameObject.AddComponent<ClickEvent>();
                if (!boxCollider)
                {
                    var a = item.gameObject.AddComponent<BoxCollider>();
                    a.isTrigger = true;
                }
            }
        }
    }

    [ContextMenu("添加碰撞检测器")]
    public void addBoxCollider()
    {
        //BoxCollider boxCollider = GetComponent<BoxCollider>();
        //Renderer renderer = null;
        //if (!boxCollider)
        //{
        //    try
        //    {
        //        renderer = transform.Find(transform.name).GetComponent<Renderer>();
        //    }
        //    catch (Exception)
        //    {
        //        renderer = transform.GetComponent<Renderer>();
        //    }
        //    if (renderer != null)
        //    {
        //        var initrot = transform.rotation;
        //        transform.rotation = Quaternion.identity;

        //        var bounds = renderer.bounds;
        //        var a = transform.gameObject.AddComponent<BoxCollider>();
        //        a.isTrigger = false;
        //        a.center = bounds.center - transform.transform.position;

        //        a.size = bounds.size;

        //        transform.rotation = initrot;
        //    }
        //}


        MeshFilter meshFilter = GetComponent<MeshFilter>();
        if (meshFilter != null)
        {
            MeshCollider meshCollider = gameObject.GetComponent<MeshCollider>();
            if (meshCollider == null)
            {
                meshCollider = gameObject.AddComponent<MeshCollider>();
            }
            meshCollider.sharedMesh = meshFilter.sharedMesh;
            meshCollider.convex = true; // 如果物体有镂空，可能需要将convex属性设置为true
        }
    }
}