using CG.Framework;
using CG.UTility;
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace ZXK.GYJQR
{
    /// <summary>
    /// 控制设备部件的显示和高亮效果
    /// </summary>
    public class AcquaintPartCtrl : MonoBehaviour
    {
        /// <summary>
        /// 模型信息数据列表
        /// </summary>
        private Dictionary<string, GameObject> _selectGeoDic = new Dictionary<string, GameObject>();

        private string _curShowModelName;

        [SerializeField]
        private Material _baseNoAlpha = null;
        [SerializeField]
        private Material _baseAlpha = null;
        private GameObject _baseGeo = null;

        /// <summary>
        /// 当前高亮显示的模型的泛光效果列表，方便关闭其他亮着的
        /// </summary>
        private List<OutLineRender> _currentHighlights = new List<OutLineRender>();

        private Ray _ray;
        private RaycastHit _rayHit;
        private GameObject _clickedObject;
        private float _doubleClickGeoInterval = 0.3f;
        private float _curClickTime = 0;

        //鼠标按下后没有位移才触发点击操作
        private bool _mouseDown = false;
        private Vector2 _mouseMove = Vector2.zero;

        public void Enter()
        {
            PopUpMng.PopToast("单击场景/部件栏中的部件，可查看介绍；双击场景/部件栏中的部件，可独立显示；", -1,UIGroup.Main);
            transform.GetChild(0).gameObject.SetActive(false);
            transform.GetChild(1).gameObject.SetActive(false);
            gameObject.SetActive(true);
            _curShowModelName = GameManager.Instance._DataBJCJHandler._ShowPartsName.Value;
            transform.Find(_curShowModelName).gameObject.SetActive(true);
            GameManager.Instance._DataBJCJHandler._CurBJRZhandler.OnValueChanged += OnSelectInfoChanged;
            AddOutlineAndColliders();
        }

        private void Update()
        {
            if (!PopUpMng._TriAble) return;
            //Camera.main.GetComponent<CameraAroundCtrl>()._STRForbid = false;

            if (Input.GetMouseButtonDown(0))
            {
                _mouseDown = true;
                _mouseMove = Vector2.zero;
            }
            if (Input.GetMouseButton(0))
            {
                if (_mouseDown)
                {
                    float mouse_x = Input.GetAxis("Mouse X");
                    float mouse_y = Input.GetAxis("Mouse Y");
                    _mouseMove += new Vector2(mouse_x, mouse_y);
                }
            }
            _ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            if (Physics.Raycast(_ray, out _rayHit))
            {
                if (Input.GetMouseButtonDown(0))
                {
                    if (Time.time - _curClickTime < _doubleClickGeoInterval)
                    {//双击物体，独立显示
                        if (BJCZSceneCtrl._Instance._OnlyShowGeo)
                        {
                            BJCJ_INFO bjrzInfo = GameManager.Instance._DataBJCJHandler._CurBJRZhandler.GetValue()[_curShowModelName];
                            if (bjrzInfo == null) return;
                            GameManager.Instance._DataBJCJHandler._CurBJRZhandler.SetValue(_curShowModelName, bjrzInfo);
                        }
                        else
                        {
                            if (_clickedObject == _rayHit.collider.gameObject)
                            {
                                if (_clickedObject.GetComponent<OutLineRender>())
                                {
                                    DoubleClickShow(_curShowModelName, _clickedObject.name);
                                }
                                else
                                {
                                    System.Action<GameObject> myAction = (geoParent) =>
                                    {
                                        DoubleClickShow(_curShowModelName, geoParent.name);                                        
                                    };
                                    _clickedObject.transform.SendMessageUpwards("TriCallAction", myAction);
                                }
                            }
                        }
                        _curClickTime = 0;
                    }
                    _curClickTime = Time.time;
                }
                if (Input.GetMouseButtonUp(0) && _mouseMove == Vector2.zero)
                {
                    _mouseDown = false;
                    _mouseMove = Vector2.zero;
                    //_ray = Camera.main.ScreenPointToRay(Input.mousePosition);

                    //if (Physics.Raycast(_ray, out _rayHit))
                    //{
                    _clickedObject = _rayHit.collider.gameObject;
                    GameObject stringParent = null;
                    WDebug.Log($"射线检测到的模型：{_clickedObject.name}");
                    if (_clickedObject.GetComponent<OutLineRender>())
                    {
                        HighlightModel(_clickedObject);
                        stringParent = _clickedObject;
                    }
                    else
                    {
                        System.Action<GameObject> myAction = (geoParent) =>
                        {
                            HighlightModel(geoParent);
                            stringParent = geoParent;
                        };
                        _clickedObject.transform.SendMessageUpwards("TriCallAction", myAction);
                    }

                    if (BJCZSceneCtrl._Instance._OnlyShowGeo == null)
                    {
                        // 获取并处理模型信息
                        BJCJ_INFO bjrzInfo = GameManager.Instance._DataBJCJHandler.GetBJRZInfoByPartName(stringParent.name);
                        GameManager.Instance._DataBJCJHandler._CurBJRZhandler.SetValue(_curShowModelName, bjrzInfo);
                    }
                }
                //Camera.main.GetComponent<CameraAroundCtrl>()._STRForbid = true;
            }
        }
        public void End()
        {
            GameManager.Instance._DataBJCJHandler._CurBJRZhandler.OnValueChanged -= OnSelectInfoChanged;
            GameManager.Instance._DataBJCJHandler._CurBJRZhandler.SetDefault();
            gameObject.SetActive(false);
        }
        private void OnDestroy()
        {
            End();
        }
        private void OnSelectInfoChanged(Dictionary<string, BJCJ_INFO> obj)
        {
            Show(obj[_curShowModelName].itemGeo);
        }
        private void Show(string geoName)
        {
            transform.Find(_curShowModelName).gameObject.SetActive(true);
            if (_selectGeoDic.ContainsKey(geoName))
            {
                if (BJCZSceneCtrl._Instance._OnlyShowGeo)
                {
                    DestroyImmediate(BJCZSceneCtrl._Instance._OnlyShowGeo);
                    BJCZSceneCtrl._Instance._OnlyShowGeo = null;
                }
                WDebug.Log($"显示模型：{_selectGeoDic[geoName]}");
                HighlightModel(_selectGeoDic[geoName]);
            }
        }

        /// <summary>
        /// 双击某个物体，独立显示
        /// </summary>
        /// <param name="showGroupName">所属父物体</param>
        /// <param name="geoName">显示物体</param>
        public void DoubleClickShow(string showGroupName, string geoName)
        {
            if (_selectGeoDic.ContainsKey(geoName))
            {
                //独显摄像机设置
                CameraAroundCtrl cameraCtrl = null;
                if (Camera.main.TryGetComponent(out cameraCtrl))
                {
                    ItemInfoCtrl itemInfo = _selectGeoDic[geoName].GetComponent<ItemInfoCtrl>();
                    if (itemInfo)
                    {
                        cameraCtrl.CameraToTarget(
                            itemInfo.transform.position + itemInfo._CameraRelaticeSelfPos
                            , itemInfo._CameraZoomSize);
                    }
                }


                Vector3 pos = _selectGeoDic[geoName].transform.position;
                Quaternion rot = _selectGeoDic[geoName].transform.rotation;
                Vector3 scale = _selectGeoDic[geoName].transform.localScale;
                BJCZSceneCtrl._Instance._OnlyShowGeo = Instantiate(_selectGeoDic[geoName],transform);
                BJCZSceneCtrl._Instance._OnlyShowGeo.transform.position = pos;
                BJCZSceneCtrl._Instance._OnlyShowGeo.transform.rotation = rot;
                BJCZSceneCtrl._Instance._OnlyShowGeo.transform.localScale = scale;
                if (geoName.Equals("SM_jixiezhuti_erzhouzhuti"))
                {
                    BJCZSceneCtrl._Instance._OnlyShowGeo.transform.Find("group1/SM_jixiezhuti410").GetComponent<MeshRenderer>().material = _baseNoAlpha;
                    BJCZSceneCtrl._Instance._OnlyShowGeo.transform.Find("SM_jixiezhuti_erzhouwaike1").GetComponent<MeshRenderer>().material = _baseNoAlpha;
                    BJCZSceneCtrl._Instance._OnlyShowGeo.transform.Find("SM_jixiezhuti_erzhouwaike2").GetComponent<MeshRenderer>().material = _baseNoAlpha;
                }
                transform.Find(showGroupName).gameObject.SetActive(false);
            }
        }
        /// <summary>
        /// 为每个模型添加泛光效果和碰撞器
        /// </summary>
        private void AddOutlineAndColliders()
        {
            foreach (var item in GameManager.Instance._DataBJCJHandler._BJRZDataArray)
            {
                string partsName = item.Key;
                for (int i = 0; i < item.Value.Count; i++)
                {
                    if (_selectGeoDic.ContainsKey(item.Value[i].itemGeo)) continue;
                    GameObject geo =UtilitiesMng.GetGeoByName(transform.Find(partsName), item.Value[i].itemGeo);
                    if (geo)
                    {
                        AddOutline(geo);
                        AddCollider(geo);
                        _selectGeoDic.Add(item.Value[i].itemGeo, geo);
                    }
                }
            }
        }
        /// <summary>
        /// 为模型添加泛光效果
        /// </summary>
        /// <param name="model">要添加泛光效果的模型</param>
        private void AddOutline(GameObject model)
        {
            OutLineRender outlineRender;

            // 如果模型上没有泛光效果组件，则添加一个新的
            if (!model.TryGetComponent(out outlineRender))
            {
                outlineRender = model.AddComponent<OutLineRender>();
            }

            // 设置泛光强度和默认禁用泛光效果
            outlineRender.OutLineStrength = 1;
            outlineRender.enabled = false;

            // 将泛光效果组件添加到高亮列表中
            _currentHighlights.Add(outlineRender);
        }
        /// <summary>
        /// 为模型添加碰撞器
        /// </summary>
        /// <param name="model">要添加碰撞器的模型</param>
        private void AddCollider(GameObject model)
        {
            // 如果模型没有碰撞器，则添加一个新的
            if (model.GetComponent<Collider>() == null)
            {
                if(model.GetComponent<MeshFilter>() == null)
                {
                    //给子物体添加碰撞器，触发碰撞效果
                    model.AddComponent<ItemTriCtrl>();
                    MeshFilter[] meshes = model.GetComponentsInChildren<MeshFilter>();
                    for (int a = 0; a < meshes.Length; a++)
                    {
                        meshes[a].gameObject.AddComponent<MeshCollider>();
                    }
                }
                else
                {
                    model.AddComponent<MeshCollider>();
                }
            }
        }

        /// <summary>
        /// 高亮显示指定的模型
        /// </summary>
        /// <param name="model">要高亮显示的模型。</param>
        private void HighlightModel(GameObject model)
        {
            foreach (var outline in _currentHighlights)
            {
                outline.enabled = (outline.gameObject == model);
            }
            //此处对于基座显示的特殊处理
            if (model.name.Equals("SM_jixiezhuti_erzhouzhuti") && _baseGeo == null)
            {
                _baseGeo = model;
            }
            if (_baseGeo)
            {
                if (model.name.Equals("SM_jixiezhuti_erzhouzhuti"))
                {
                    _baseGeo = model;
                    _baseGeo.transform.Find("group1/SM_jixiezhuti410").GetComponent<MeshRenderer>().material = _baseNoAlpha;
                    //Material baseMat = _baseGeo.transform.Find("group1/SM_jixiezhuti410").GetComponent<MeshRenderer>().material;
                    //Color baseColor = baseMat.GetColor("_BaseColor");
                    //baseMat.SetColor("_BaseColor", new Color(baseColor.r, baseColor.g, baseColor.b, 1.0f));
                }
                else
                {
                    _baseGeo.transform.Find("group1/SM_jixiezhuti410").GetComponent<MeshRenderer>().material = _baseAlpha;
                    //Material baseMat = _baseGeo.transform.Find("group1/SM_jixiezhuti410").GetComponent<MeshRenderer>().material;
                    //Color baseColor = baseMat.GetColor("_BaseColor");
                    //baseMat.SetColor("_BaseColor", new Color(baseColor.r, baseColor.g, baseColor.b, 0.4f));
                }
            }            
        }
    }
}