using UnityEngine;
using System.Collections.Generic;
using UnityEngine.UI;
using DevelopEngine;
using AX.MessageSystem;
using System;
using System.IO;
using System.Collections;
using UnityEngine.EventSystems;
//using UIManage;
/// <summary>
/// 树形菜单控制器
/// </summary>
public class TreeViewControl__ : SingletonMono<TreeViewControl__>, IPointerEnterHandler
{
    /// <summary>
    /// 当前树形菜单的数据源
    /// </summary>
    [HideInInspector]
    public List<TreeViewData> Data = null;

    /// <summary>
    /// 树形菜单中元素的模板
    /// </summary>
    public GameObject Template;
    /// <summary>
    /// 树形菜单中元素的根物体
    /// </summary>
    public Transform TreeItems;
    /// <summary>
    /// 树形菜单的纵向排列间距
    /// </summary>
    public int VerticalItemSpace = 2;
    /// <summary>
    /// 树形菜单的横向排列间距
    /// </summary>
    public int HorizontalItemSpace = 25;
    /// <summary>
    /// 树形菜单中元素的宽度
    /// </summary>
    public int ItemWidth = 230;
    /// <summary>
    /// 树形菜单中元素的高度
    /// </summary>
    public int ItemHeight = 35;
    /// <summary>
    /// 所有子元素的鼠标点击回调事件
    /// </summary>
    public delegate void ClickItemdelegate(GameObject item);
    public event ClickItemdelegate ClickItemEvent;

    //当前树形菜单中的所有元素
    public List<GameObject> _treeViewItems;
    //当前树形菜单中的所有元素克隆体（刷新树形菜单时用于过滤计算）
    private List<GameObject> _treeViewItemsClone;
    //树形菜单当前刷新队列的元素位置索引
    private int _yIndex = 0;
    //树形菜单当前刷新队列的元素最大层级
    private int _hierarchy = 0;
    /// <summary>
    /// 标志图层数据是否被编辑过的标志位
    /// </summary>
    public bool HasEditFlag = false;
    public bool ViewButtonHoverTipFlag = false;
    private GameObject TipText;

    Canvas canvas;
    GameObject objTemp;
    RectTransform rectContent;
    private GameObject btns;
    void Awake()
    {
        ClickItemEvent += ClickItemTemplate;       

        TipText = transform.Find("TipText").gameObject;

        //TransformHelper.FindChild(transform, "Viewport").gameObject.AddComponent<TreeViewItemEnter>();
        //TransformHelper.FindChild(transform, "Content").gameObject.AddComponent<TreeViewItemEnter>();
    }
    void Start()
    {
        GetLayersData();
        GenerateTreeView();

        ChangeChildren(false);

        RefreshTreeView();

        rectContent = TransformHelper.FindChild(transform,"Content").GetComponent<RectTransform>();
        rectTree = GetComponent<RectTransform>();
        rect = new Rect(0, -rectTree.sizeDelta.y, rectTree.sizeDelta.x, rectTree.sizeDelta.y);
        canvas = GameObject.Find("Canvas").GetComponent<Canvas>();
        ItemTipText = TransformHelper.FindChild(transform, "ItemTipText").GetComponent<Text>();
        width = GetComponent<RectTransform>().sizeDelta.x;
    }

    Vector2 mosPos;
    Vector2 mosPos_tree;
    Vector2 itemPos;
    RectTransform tvi;
    private Text ItemTipText;
    private bool InRectFlag = false;
    private GameObject hoverItem;
    private bool hasHoverItemFlag = false;
    private float width;

    private RectTransform rectTree;
    private Rect rect;

    void Update()
    {
        if (RectTransformUtility.ScreenPointToLocalPointInRectangle(rectTree,
              Input.mousePosition, canvas.worldCamera, out mosPos_tree))
        {
            if (hoverItem)
            {
                btns = TransformHelper.FindChild(hoverItem.transform, "btns").gameObject;
                btns.SetActive(false);
            }

            ItemTipText.gameObject.SetActive(false);
            hasHoverItemFlag = false;

            if (!rect.Contains(mosPos_tree))
            {
                return;
            }
        }
        if (RectTransformUtility.ScreenPointToLocalPointInRectangle(rectContent,
          Input.mousePosition, canvas.worldCamera, out mosPos))
        {
            //Debug.Log("mosPos" + mosPos);
            

            if (mosPos.x >= 0 && mosPos.x <= width)
            {
                foreach (var item in _treeViewItems)
                {
                    itemPos = item.GetComponent<RectTransform>().anchoredPosition;
                    if (item.activeSelf && mosPos.y >= itemPos.y - 22 && mosPos.y <= itemPos.y - 6)//鼠标在item范围内
                    {
                        hoverItem = item;
                        hasHoverItemFlag = true;
                        //Debug.Log("*****************************************************in:" + hoverItem.transform.Find("TreeViewText").GetComponent<Text>().text);
                        break;
                    }

                }
                if (hasHoverItemFlag)
                {
                    btns = TransformHelper.FindChild(hoverItem.transform, "btns").gameObject;
                    btns.SetActive(true);
                    ItemTipText.text = hoverItem.transform.Find("TreeViewText").GetComponent<Text>().text;
                    ItemTipText.GetComponent<RectTransform>().anchoredPosition = new Vector2(0, mosPos_tree.y + 106);
                    ItemTipText.gameObject.SetActive(true);
                }
            }
        }
    }

    void ChangeChildren(bool value)
    {
        //复制一份菜单
        _treeViewItemsClone = new List<GameObject>(_treeViewItems);

        //用复制的菜单进行刷新计算
        for (int i = 0; i < _treeViewItemsClone.Count; i++)
        {
            TreeViewItem__ tvi = _treeViewItemsClone[i].GetComponent<TreeViewItem__>();

            if (tvi.GetHierarchy() >= 1)
            {
                //ChangeChildren(tvi, value);

                tvi.IsExpanding = false;
                tvi.gameObject.SetActive(value);
                tvi.transform.Find("ContextButton").GetComponent<RectTransform>().localRotation = Quaternion.Euler(0, 0, 89.99f);
            }
            else
            {
                tvi.IsExpanding = false;
                tvi.transform.Find("ContextButton").GetComponent<RectTransform>().localRotation = Quaternion.Euler(0, 0, 89.99f);
            }
        }
    }

    void ChangeChildren(TreeViewItem__ tvi, bool value)
    {
        tvi.IsExpanding = value;

        for (int i = 0; i < tvi.GetChildrenNumber(); i++)
        {
            tvi.GetChildrenByIndex(i).gameObject.SetActive(value);
            ChangeChildren(tvi.GetChildrenByIndex(i), value);
        }
    }


    public void SetAllToggleFalse(int id)
    {
        foreach(Transform child in TreeItems)
        {
            if (child.Find("TreeViewToggle").GetComponent<Toggle>().isOn && child.GetComponent<TreeViewItem__>().ID != id)
            {
                child.Find("TreeViewToggle").GetComponent<Toggle>().isOn = false;
            }
            
        }
    }
    public void SetToggleTrue(int id)
    {
        foreach (Transform child in TreeItems)
        {
            child.Find("TreeViewToggle").GetComponent<Toggle>().isOn = false;
            if (child.GetComponent<TreeViewItem__>().ID == id)
            {
                child.Find("TreeViewToggle").GetComponent<Toggle>().isOn = true;
            }
        }
    }
    public GameObject GetToggleGame()
    {
        foreach (Transform child in TreeItems)
        {
            if (child.GetComponent<TreeViewItem__>().ID == TempDataManager.Instance.CurNodeID)
            {
                return child.gameObject;
            }
        }
        return null;
    }
    public bool CheckFileTreeItems()
    {
        foreach (Transform child in TreeItems)
        {
            if (child.GetComponent<TreeViewItem__>().ID == TempDataManager.Instance.CurNodeID)
            {
                var data = child.GetComponent<TreeViewItem__>().Name;
                var filepath = ExamInfoHelpClass.CurrentWorkPath + data + ".xml";
                if (File.Exists(filepath)) //判断有没有对应的xml文件，设置字体大小是否自适应最佳
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }

        return false;
    }

    public void ShowTip(bool flag)
    {
        TipText.SetActive(flag);
    }

    void test( ref List<TreeViewData> datas)
    {
        TreeViewData data = new TreeViewData();
        data.ID = 0;
        data.Name = "第一章";
        data.ParentID = -1;
        data.Hierarchy = 0;
        datas.Add(data);

        data = new TreeViewData();
        data.ID = 1;
        data.Hierarchy = 1;
        data.Name = "1.第一节";
        data.ParentID = 0;
        datas.Add(data);

        data = new TreeViewData();
        data.ID = 2;
        data.Hierarchy = 1;
        data.Name = "1.第二节";
        data.ParentID = 0;
        datas.Add(data);

        data = new TreeViewData();
        data.ID = 3;
        data.Hierarchy = 2;
        data.Name = "1.1.第一课";
        data.ParentID = 1;
        datas.Add(data);

        data = new TreeViewData();
        data.ID = 4;
        data.Hierarchy = 2;
        data.Name = "1.2.第一课";
        data.ParentID = 1;
        datas.Add(data);

        data = new TreeViewData();
        data.ID = 5;
        data.Hierarchy = 2;
        data.Name = "1.2.第一课";
        data.ParentID = 2;
        datas.Add(data);

        data = new TreeViewData();
        data.ID = 6;
        data.Hierarchy = 2;
        data.Name = "1.2.第一课";
        data.ParentID = 2;
        datas.Add(data);

    }

    void GetLayersData()
    {
        //生成数据
        List<TreeViewData> datas = new List<TreeViewData>();
        //var dataList = DAO<TreeViewData>.GetAllInfos(GlobalHelpClass.fixedLayersTableName);
        //dataList.ForEach(d => { datas.Add(d); });
        //指定数据源
        //test(ref datas);
        NodeSet.Instance.GetAllDates(ref datas);
        Debug.Log(datas.Equals(Data));
        Data = datas;
        //GetLayersHierarchy();
    }

    public Dictionary<TreeViewData, Dictionary<TreeViewData, List<TreeViewData>>> GetLayersHierarchy()
    {
        Dictionary<TreeViewData, Dictionary<TreeViewData, List<TreeViewData>>> layersDic = new Dictionary<TreeViewData, Dictionary<TreeViewData, List<TreeViewData>>>();
        foreach(var data in Data)
        {
            if (data.Hierarchy == 0)//1级结构
            {
                if (!layersDic.ContainsKey(data))
                {
                    layersDic.Add(data, new Dictionary<TreeViewData, List<TreeViewData>>());
                }
            }
            else if(data.Hierarchy == 1)//2级结构，父级结构已经都有了
            {
                //首先根据parentID找到父层级data 
                TreeViewData key_data = data;
                foreach(var key in layersDic.Keys)
                {
                    if (key.ID == data.ParentID)
                    {
                        key_data = key;
                    }
                }
                if (!layersDic[key_data].ContainsKey(data))
                {
                    layersDic[key_data].Add(data, new List<TreeViewData>());
                }
            }
            else if(data.Hierarchy == 2)//3级结构
            {
                TreeViewData key_data_1 = data;//找到1级结构
                TreeViewData key_data_2 = data;//找到2级结构
                foreach(var key_1 in layersDic.Keys)
                {
                    foreach(var key_2 in layersDic[key_1].Keys)
                    {
                        if (key_2.ID == data.ParentID)
                        {
                            key_data_1 = key_1;
                            key_data_2 = key_2;
                        }
                    }
                }
                if (!layersDic[key_data_1][key_data_2].Contains(data))
                {
                    layersDic[key_data_1][key_data_2].Add(data);
                }
            }
        }
        return layersDic;
    }

    public void RemoveItem(int id)
    {
        for (int i = Data.Count - 1; i >= 0; i--)
        {
            if (Data[i].ID == id)
            {
                Data.Remove(Data[i]);
                return;
            }
        }
    }
    /// <summary>
    /// 生成一个新的ID，目前默认取最后一个元素的ID+1，暂时没有考虑删除中间元素后所有ID重新赋值排序
    /// </summary>
    /// <returns>返回新元素的ID</returns>
    public int GetNewID()
    {
        int id = 0;
        id = Data[Data.Count - 1].ID + 1;
        return id;
    }
    /// <summary>
    /// 鼠标点击子元素事件
    /// </summary>
    public void ClickItemAdd(GameObject item)
    {
        ClickItemEvent(item);
    }
    void ClickItemTemplate(GameObject item)
    {
        //空的事件，不这样做的话ClickItemEvent会引发空引用异常
    }

    public int GetFirstlayerIdByCurItemID(int curId)
    {
        var data = Data.Find(d => { return (d.ID == curId); });
        var parentID = data.ParentID;
        if (parentID == -1)
        {
            return curId;
        }
        else
        {
            return GetFirstlayerIdByCurItemID(parentID);
        }
    }

    public int GetSecondlayerIdByCurItemID(int curId)
    {
        var data = Data.Find(d => { return (d.ID == curId); });
        var Hierarchy = data.Hierarchy;
        if (Hierarchy <= 1)
        {
            return curId;
        }
        else//如果Hierarchy不为1,则所选物体处于三级菜单，此时返回其父物体二级菜单的ID
        {
            return (data.ParentID);
        }
    }


    /// <summary>
    /// 返回指定名称的子元素是否被勾选
    /// </summary>
    public bool ItemIsCheck(string itemName)
    {
        for (int i = 0; i < _treeViewItems.Count; i++)
        {
            if (_treeViewItems[i].transform.Find("TreeViewText").GetComponent<Text>().text == itemName)
            {
                return _treeViewItems[i].transform.Find("TreeViewToggle").GetComponent<Toggle>().isOn;
            }
        }
        return false;
    }
    /// <summary>
    /// 返回树形菜单中被勾选的所有子元素名称
    /// </summary>
    public List<string> ItemsIsCheck()
    {
        List<string> items = new List<string>();

        for (int i = 0; i < _treeViewItems.Count; i++)
        {
            if (_treeViewItems[i].transform.Find("TreeViewToggle").GetComponent<Toggle>().isOn)
            {
                items.Add(_treeViewItems[i].transform.Find("TreeViewText").GetComponent<Text>().text);
            }
        }

        return items;
    }

    /// <summary>
    /// 生成树形菜单
    /// </summary>
    public void GenerateTreeView()
    {
        //删除可能已经存在的树形菜单元素
        if (_treeViewItems != null)
        {
            for (int i = 0; i < _treeViewItems.Count; i++)
            {
                Destroy(_treeViewItems[i]);
            }
            _treeViewItems.Clear();
        }
        //重新创建树形菜单元素
        _treeViewItems = new List<GameObject>();
        for (int i = 0; i < Data.Count; i++)
        {
            InstanATreeViewItem(Data[i]);
        }

        //SetTreeViewItemToggle();//筛选toggle是否开启
    }
    public GameObject InstanATreeViewItem(TreeViewData data, int index = -1, bool Flag = false)
    {
        if ((data.Name.Contains("设施信息aaaaaaaaaaaa") && data.Hierarchy == 1))
            return null;
        GameObject item = Instantiate(Template);
        item.GetComponent<TreeViewItem__>().SetID(data);
        if (data.ParentID == -1)
        {
            item.GetComponent<TreeViewItem__>().SetHierarchy(0);
            item.GetComponent<TreeViewItem__>().SetParent(null);
        }
        else
        {
            //TreeViewItem tvi = _treeViewItems[data.ParentID].GetComponent<TreeViewItem>();
            TreeViewItem__ tvi = GetTreeViewItemByID(data.ParentID);
            item.GetComponent<TreeViewItem__>().SetHierarchy(tvi.GetHierarchy() + 1);
            item.GetComponent<TreeViewItem__>().SetParent(tvi);
            if (Flag)
            {
                tvi.InsertChildren(item.GetComponent<TreeViewItem__>(), index);
            }
            else
            {
                tvi.AddChildren(item.GetComponent<TreeViewItem__>());
            }
        }

        item.transform.name = "TreeViewItem";
        var textCompent = item.transform.Find("TreeViewText").GetComponent<Text>();
        if (data.Name.Contains("-"))
        {
            string[] str = data.Name.Split('-');
            textCompent.text = str[str.Length - 1];
        }
        else
        {
            textCompent.text = data.Name;
        }

        var filepath = ExamInfoHelpClass.CurrentWorkPath + data.Name + ".xml";
        if (File.Exists(filepath)) //判断有没有对应的xml文件，设置字体大小是否自适应最佳
        {
            //textCompent.resizeTextForBestFit = false;
        }
        else
        {
            //textCompent.resizeTextForBestFit = true;
        }
        item.GetComponent<TreeViewItemButtonClick>().SetView(data.View);
        item.transform.SetParent(TreeItems);
        item.transform.localPosition = Vector3.zero;
        item.transform.localScale = Vector3.one;
        item.transform.localRotation = Quaternion.Euler(Vector3.zero);
        item.SetActive(true);

        _treeViewItems.Add(item);

        return item;
    }
    /// <summary>
    /// 开启/关闭可见属性时，维护Data数组
    /// </summary>
    /// <param name="id"></param>
    public void SetViewOfData(int id, bool flag)
    {
        var data = Data.Find(d => { return d.ID == id; });
        data.View = flag;
    }
    /// <summary>
    /// 设置属性元素的toggle是否可用
    /// 原则：元素存在子物体即隐藏toggle
    /// </summary>
    private void SetTreeViewItemToggle()
    {
        foreach (var item in _treeViewItems)
        {
            if (item.GetComponent<TreeViewItem__>().GetChildrenNumber() > 0)
            {
                item.transform.Find("TreeViewToggle").gameObject.SetActive(false);
            }
            else
            {
                item.transform.Find("TreeViewToggle").gameObject.SetActive(true);
            }
        }
    }
    private TreeViewItem__ GetTreeViewItemByID(int id)
    {
        foreach(var item in _treeViewItems)
        {
            if (item.GetComponent<TreeViewItem__>().ID == id)
            {
                return item.GetComponent<TreeViewItem__>();
            }
        }
        return null;
    }
    /// <summary>
    /// 获取当前是否有图层被选中
    /// </summary>
    /// <returns></returns>
    public int HasItemSelected()
    {
        foreach (Transform item in TreeItems)
            if (item.GetComponentInChildren<Toggle>() && item.GetComponentInChildren<Toggle>().isOn)
                return item.GetComponent<TreeViewItem__>().ID;

        return -1;
    }
    /// <summary>
    /// 刷新树形菜单
    /// </summary>
    public void RefreshTreeView()
    {
        _yIndex = 0;
        _hierarchy = 0;

        //复制一份菜单
        _treeViewItemsClone = new List<GameObject>(_treeViewItems);

        //用复制的菜单进行刷新计算
        for (int i = 0; i < _treeViewItemsClone.Count; i++)
        {
            //已经计算过或者不需要计算位置的元素
            if (_treeViewItemsClone[i] == null || !_treeViewItemsClone[i].activeSelf)
            {
                continue;
            }

            TreeViewItem__ tvi = _treeViewItemsClone[i].GetComponent<TreeViewItem__>();

            _treeViewItemsClone[i].GetComponent<RectTransform>().anchoredPosition = new Vector3(tvi.GetHierarchy() * HorizontalItemSpace, _yIndex,0);
            _yIndex += (-(ItemHeight + VerticalItemSpace));
            if (tvi.GetHierarchy() > _hierarchy)
            {
                _hierarchy = tvi.GetHierarchy();
            }


            if (tvi.IsExpanding)
            {
                RefreshTreeViewChild(tvi);
            }
            

            _treeViewItemsClone[i] = null;
        }

        //重新计算滚动视野的区域
        float x = _hierarchy * HorizontalItemSpace + ItemWidth;
        float y = Mathf.Abs(_yIndex) + ItemHeight / 2;
        transform.GetComponent<ScrollRect>().content.sizeDelta = new Vector2(x, y);

        //清空复制的菜单
        _treeViewItemsClone.Clear();


    }
    /// <summary>
    /// 根据名字找到对应的层级
    /// </summary>
    public bool GetHierarchy_Name(int Hierarchy,string Name)
    {
        foreach (Transform item in TreeItems)
        {
            if (item.GetComponent<TreeViewItem__>().GetHierarchy()==Hierarchy
                && item.GetComponent<TreeViewItem__>().Name.Equals(Name))
            {
                return true;
            }
            if (Hierarchy == 0 && item.GetComponent<TreeViewItem__>().Name.Equals(Name))
            {
                return true;
            }
        }
        return false;
    }

    public void AddNode(string nodeName)
    {
        foreach (Transform item in TreeItems)
        {
            if (item.GetComponentInChildren<Toggle>() && item.GetComponentInChildren<Toggle>().isOn)
            {
                var treeViewItem = item.GetComponent<TreeViewItem__>();
                var count = treeViewItem.GetChildrenNumber();
                var filepath = ExamInfoHelpClass.CurrentWorkPath + treeViewItem.Name + ".xml";
                if (!File.Exists(filepath) && treeViewItem.GetHierarchy() < treeViewItem.maxHierarchy - 1)//新建节点添加到该层级下，Add即可
                {
                    var pid = treeViewItem.ID;
                    TreeViewData data = new TreeViewData();
                    data.Name = nodeName;
                    //data.ID = GetComponent<TreeViewItem__>().Controler.GetNewID();
                    data.ID = NodeSet.Instance.GetNextID();
                    data.ParentID = pid;
                    data.Hierarchy = treeViewItem.GetHierarchy() + 1;
                    Data.Add(data);
                    var treeViewItemObj = InstanATreeViewItem(data);
                    treeViewItemObj.SetActive(treeViewItem.IsExpanding);
                    //GenerateTreeView();
                    RefreshTreeView();
                    HasEditFlag = true;

                    NodeSet.Instance.ADDXml(nodeName, data);
                    //MessageDispatcher.SendMessage("AddNode", data);
                }
                else//新建节点添加到该节点后边，需要Insert
                {
                    //if(!File.Exists(filepath) && treeViewItem.GetHierarchy() < treeViewItem.maxHierarchy - 1)
                    //{
                    //    var pid1 = treeViewItem.ID;
                    //    TreeViewData data1 = new TreeViewData();
                    //    data1.Name = nodeName;
                    //    //data.ID = GetComponent<TreeViewItem__>().Controler.GetNewID();
                    //    data1.ID = NodeSet.Instance.GetNextID();
                    //    data1.ParentID = pid1;
                    //    data1.Hierarchy = treeViewItem.GetHierarchy() + 1;
                    //    Data.Add(data1);

                    //    GenerateTreeView();
                    //    RefreshTreeView();
                    //    HasEditFlag = true;

                    //    NodeSet.Instance.ADDXml(nodeName, data1);
                    //    //MessageDispatcher.SendMessage("AddNode", data);
                    //    return;
                    //}
                    var pid = treeViewItem.parentID;
                    TreeViewData data = new TreeViewData();
                    data.Name = nodeName;
                    //data.ID = GetComponent<TreeViewItem__>().Controler.GetNewID();
                    data.ID = NodeSet.Instance.GetNextID();
                    data.ParentID = pid;
                    data.Hierarchy = treeViewItem.GetHierarchy();
                    var childList = treeViewItem.GetParent().GetChildrenList();
                    //Data.Add(data);
                    var index = Data.FindIndex(d => { return d.ID == treeViewItem.ID; });
                    Data.Insert(index + 1, data);//插入在该节点后边

                    int index_item = childList.FindIndex(t => { return t.ID == treeViewItem.ID; });
                    InstanATreeViewItem(data, index_item + 1, true);
                    //GenerateTreeView();
                    RefreshTreeView();
                    HasEditFlag = true;


                    NodeSet.Instance.InsertXml(treeViewItem.ID.ToString(), data);
                }
            }
        }
    }

    /// <summary>
    /// 刷新元素的所有子元素
    /// </summary>
    void RefreshTreeViewChild(TreeViewItem__ tvi)
    {
        for (int i = 0; i < tvi.GetChildrenNumber(); i++)
        {
            tvi.GetChildrenByIndex(i).gameObject.GetComponent<RectTransform>().anchoredPosition = new Vector3(tvi.GetChildrenByIndex(i).GetHierarchy() * HorizontalItemSpace, _yIndex, 0);
            _yIndex += (-(ItemHeight + VerticalItemSpace));
            if (tvi.GetChildrenByIndex(i).GetHierarchy() > _hierarchy)
            {
                _hierarchy = tvi.GetChildrenByIndex(i).GetHierarchy();
            }

            if (tvi.GetChildrenByIndex(i).IsExpanding)
            {
                RefreshTreeViewChild(tvi.GetChildrenByIndex(i));
            }

            int index = _treeViewItemsClone.IndexOf(tvi.GetChildrenByIndex(i).gameObject);
            if (index >= 0)
            {
                _treeViewItemsClone[index] = null;
            }
        }
    }


    /// <summary>
    /// 拖拽一个树形结构到指定位置
    /// </summary>
    /// <param name="newViewItem">新生成的（用于拖拽）</param>
    /// <param name="oldViewItem">原来的（会被删除）</param>
    public void DragTreeViewItem(TreeViewItem__ newViewItem, TreeViewItem__ oldViewItem)
    {
        if (oldViewItem.GetParent() == null||oldViewItem.GetParent().GetChildrenNumber()<=1)
        {//只有一个孩子就不拖拽了
            Destroy(newViewItem.gameObject);
           // RefreshTreeView();
            return;
        }

        //将原来属性结构上的各类值拷贝到新生成的树形结构上
        newViewItem.name = oldViewItem.name;
        newViewItem.SetHierarchy(oldViewItem.GetHierarchy());
        newViewItem.SetID(oldViewItem);
        newViewItem.SetParent(oldViewItem.GetParent());
        newViewItem.SetChildrenList(oldViewItem.GetChildrenList());
        //父物体的链表中，删除老的元素，在对应位置插入拖拽的元素
        oldViewItem.GetParent().RemoveChildren(oldViewItem);
        int num = GetInsItemNum(newViewItem);
        newViewItem.GetParent().InsertChildren(newViewItem, num);


        //修改XML中的顺序  
        //TreeViewItem__ s = newViewItem.GetParent().GetChildrenByIndex(num + 1);
        if (newViewItem.GetParent().GetChildrenByIndex(num + 1) != null)
        {
            NodeSet.Instance.TranslocationXML(newViewItem.ID.ToString(), newViewItem.GetParent().GetChildrenByIndex(num + 1).ID.ToString(), false);
        }
        else if (newViewItem.GetParent().GetChildrenByIndex(num - 1) != null)
        {
            NodeSet.Instance.TranslocationXML(newViewItem.ID.ToString(), newViewItem.GetParent().GetChildrenByIndex(num - 1).ID.ToString(), true);
        }
        else
        {
            Destroy(newViewItem);
            RefreshTreeView();
            return;
        }

        _treeViewItems.Remove(oldViewItem.gameObject);
        _treeViewItems.Add(newViewItem.gameObject);

        Destroy(oldViewItem.gameObject);
        StartCoroutine(DelaySet(num, newViewItem));
    }
    IEnumerator DelaySet(int num, TreeViewItem__ newViewItem)
    {
        yield return new WaitForEndOfFrame();       
        //重新刷新树形结构
        RefreshTreeView();
    }


    /// <summary>
    /// 拖拽时，获取拖拽的元素将要被插入链表的哪个位置
    /// </summary>
    /// <param name="newViewItem"></param>
    /// <returns></returns>
    private int GetInsItemNum(TreeViewItem__ newViewItem)
    {
        float fNewItem = newViewItem.transform.localPosition.y;
        TreeViewItem__[] itemArray= newViewItem.GetParent().GetChildrenList().ToArray();//获取子物体

        for (int i = 0; i < itemArray.Length; i++)
        {
            if (i == 0&& fNewItem >itemArray[0].transform.localPosition.y)
            {
               return 0;      
            }
            else if (i == itemArray.Length - 1 )
            {
                if (fNewItem < itemArray[i].transform.localPosition.y)
                {
                    return i+1;
                }             
            }
            else
            {
                if (fNewItem<itemArray[i].transform.localPosition.y&&fNewItem>itemArray[i+1].transform.localPosition.y)
                {
                    return i+1;
                }
            }
        }        
        return -1;
    }

    public void OnPointerEnter(PointerEventData eventData)
    {
        var items = _treeViewItems;
        foreach (var item in items)
        {
            TransformHelper.FindChild(item.transform, "btns").gameObject.SetActive(false);
        }
    }
}