using DG.Tweening;
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using ZXK.Framework;
using ZXK.UTility;
/*******************************************************************************
*Create By CG
*Function 场景中端子连线
*******************************************************************************/
namespace ZXK.BYSS
{
    public class ConnectLineCtrl : MonoBehaviour
    {
        //线路连接数据
        [SerializeField]
        public LineConnectModel _lineConnectData = null;
        [SerializeField]
        private GameObject _chatouPrefab = null;
        [SerializeField]//所有插头父物体
        private Transform _chatouContain = null;
        public TerminalCtrl _terminalStart = null;//插入的第一个端子..不是null，说明插完一个接头等待插入另一个的状态 
        public GameObject _chaTouTemp = null;//插入第一个时生成的动态线段
        public Transform _chatou0 = null;//插入后需要脱离父物体寻找位置，暂时先提取出来
        //计分时查看每个线段应该接多少个小线段
        public Dictionary<string, int> _connectLineDic = new Dictionary<string, int>();
        //智能运动系统内提前预知好的接线线段
        public Dictionary<string, GameObject> _ZNYDLines = new Dictionary<string, GameObject>();
        //每个线段有几个控制板，保证控制板之间只有一个线段连接
        public Dictionary<string, List<string>> _lineCtrlDic = new Dictionary<string, List<string>>();

        [Range(0.0f, 1.0f)]
        private float posx = 0.825f;
        [Range(0.0f, 1.0f)]
        private float posy = 0.851f;
        [Range(0.0f, 1.0f)]
        private float posz = 0.615f;
        //[Range(0.0f, 1.0f)]
        //private float rotx = 0.3f;
        //[Range(0.0f, 1.0f)]
        //private float roty = 0.3f;
        //[Range(0.0f, 1.0f)]
        //private float rotz = 0.3f;

        private void Awake()
        {
            if (EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType).Equals(transform.name))
            {
                EventCenterManager.Instance.AddEventListener(EventEnum.AutoConnect, AutoLineCall);
            }
        }
        private void OnDestroy()
        {
            if (EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType).Equals(transform.name))
            {
                EventCenterManager.Instance.RemoveListener(EventEnum.AutoConnect, AutoLineCall);
            }
        }
        private void Start()
        {
            if (EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType).Equals(transform.name))
            {
                _lineConnectData = new LineConnectModel();
                StartCoroutine(_lineConnectData.ReadLineConnectDataWeb(transform, GetCtrlTerminals));
                AppManagement.Instance._ConnectScore = 0;
                if (AppManagement.Instance._CurType == EnumCtrl.Type.ZNYD)
                {
                    //Transform[] lines = .GetComponentsInChildren<Transform>(true);
                    Transform lines = transform.Find("Aim_ZhiNengYunDongKongZhi/SM_LJDX");
                    foreach (Transform item in lines)
                    {
                        _ZNYDLines.Add(item.name, item.gameObject);
                    }
                    //for (int i = 1; i < lines.Length; i++)
                    //{
                    //    _ZNYDLines.Add(lines[i].name, lines[i].gameObject);
                    //}
                }
            }
        }
        GameObject temp;
        private void Update()
        {

            if (AppManagement.Instance._TrainExam==EnumCtrl.Model.Exam)
            {
                if (Input.GetMouseButton(2) && _terminalStart)
                {
                    Debug.Log("可以清除");
                    DestoryChaTou();



                }
            }
            else
            {
          
            
            }

         


   

        }

        public void InteractionInScene(RaycastHit rayHit)
        {
            if (!EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType).Equals(transform.name)) return;
            Debug.Log("进入连线模式！！！！");

            TerminalCtrl terminalCtrl = rayHit.transform.GetComponent<TerminalCtrl>();
            if (!TerminalInData(rayHit.transform.name))
            {
                //判空判断
                if (terminalCtrl != null)
                {
                    terminalCtrl.InsertLightState(false);

                }
                //if (_terminalStart && AppManagement.Instance._TrainExam == EnumCtrl.Model.Train)
                //{
                //    Debug.Log("练习模式！！！接线模块");
                //    //如果练习模式不在数据内，不计次数，只弹窗
                //    PopUpMng.PopCustomFailToast("操作错误", "请根据端子分配表及接线图正确接线", "确认", null);
                //}
                //if (_terminalStart && AppManagement.Instance._TrainExam == EnumCtrl.Model.Teach)
                //{
                //    Debug.Log("教学模式！！！接线模块");
                //    //如果练习模式不在数据内，不计次数，只弹窗
                //    PopUpMng.PopCustomFailToast("操作错误", "请根据端子分配表及接线图正确接线", "确认", null);
                //}

                //考核模式点击错误端子直接弹出提示
                PopUpMng.PopCustomFailToast("操作错误", "请根据端子分配表及接线图正确接线", "确认", () => {

                    DestoryChaTou();

                });

                return;
            }
            if (_terminalStart == null)
            {
                if (AppManagement.Instance._CurType == EnumCtrl.Type.XHBY ||
                    AppManagement.Instance._CurType == EnumCtrl.Type.QDCY ||
                    AppManagement.Instance._CurType == EnumCtrl.Type.ZNYD   )
                {
                    _chaTouTemp = Instantiate(_chatouPrefab, _chatouContain);
                    _chatou0 = _chaTouTemp.transform.Find("ChaTou0");
                    terminalCtrl.SetChaTouPos(_chatou0);
                    _chaTouTemp.transform.position = _chatou0.position;
                    _chaTouTemp.transform.rotation = _chatou0.rotation;
                    _terminalStart = terminalCtrl;

                    // Debug.Log("生成接头!!!!!!!");

                   
                        if (AppManagement.Instance._TrainExam == EnumCtrl.Model.Exam)
                        {
                            Debug.Log("考核模式调用这个");
                        }
                        else
                        {
                            Debug.Log("练习，教学模式调用这个");
                            SetCurrentIndexAdd();
                            SetCurrentTerminalCtrl();
                        }
                   

                }
                //材料分拣特殊模式设置
                else if (AppManagement.Instance._CurType == EnumCtrl.Type.CLFJ &&
                   terminalCtrl._CurTerminalData._ConnectGeos.Count < 1)
                {
                    if (terminalCtrl._CurTerminalData._TerminalName.Equals("DLB0.3") ||
                        terminalCtrl._CurTerminalData._TerminalName.Equals("DLB0.4") ||
                        terminalCtrl._CurTerminalData._TerminalName.Equals("DLB0.5"))
                    {//材料分拣中的特殊情况
                        terminalCtrl.StraightSetChaTouPos();
                        terminalCtrl._CurTerminalData._ConnectGeos.Add(terminalCtrl.gameObject);
                        if (terminalCtrl._CurTerminalData._TerminalName.Equals("DLB0.3"))
                        {
                            AddScore("12");
                        }
                        if (terminalCtrl._CurTerminalData._TerminalName.Equals("DLB0.4"))
                        {
                            AddScore("13");
                        }
                        if (terminalCtrl._CurTerminalData._TerminalName.Equals("DLB0.5"))
                        {
                            AddScore("14");
                        }
                        CheckAllTerminalConnect();
                    }
                    else
                    {
                        terminalCtrl.StraightSetChaTouPos();
                        _terminalStart = terminalCtrl;
                    }
                    if (AppManagement.Instance._TrainExam == EnumCtrl.Model.Exam)
                    {
                        Debug.Log("考核模式调用这个");
                    }
                    else
                    {
                        Debug.Log("练习，教学模式调用这个");
                        SetCurrentIndexAdd();
                        SetCurrentTerminalCtrl();
                    }
                }


                #region

                ////搬运输送特殊模式设置
                else if (AppManagement.Instance._CurType == EnumCtrl.Type.BYSS)
                {

                    #region 旧的接线逻辑
                    //if (terminalCtrl._CurTerminalData._ConnectGeos.Count < 1)
                    //{
                    //    if (terminalCtrl._CurTerminalData._TerminalName.Contains("SM-X"))
                    //    {
                    //        terminalCtrl.StraightSetChaTouPos();
                    //        terminalCtrl._CurTerminalData._ConnectGeos.Add(terminalCtrl.gameObject);
                    //        if (terminalCtrl._CurTerminalData._TerminalName.Equals("SM-XA"))
                    //        {
                    //            AddScore("50");
                    //        }
                    //        if (terminalCtrl._CurTerminalData._TerminalName.Equals("SM-XB"))
                    //        {
                    //            AddScore("51");
                    //        }
                    //        if (terminalCtrl._CurTerminalData._TerminalName.Equals("SM-X4"))
                    //        {
                    //            AddScore("52");
                    //        }
                    //        if (terminalCtrl._CurTerminalData._TerminalName.Equals("SM-X6"))
                    //        {
                    //            AddScore("53");
                    //        }
                    //        CheckAllTerminalConnect();
                    //    }
                    //    else
                    //    {
                    //        terminalCtrl.InsertLightState(true);
                    //        terminalCtrl._CurTerminalData._ConnectGeos.Add(terminalCtrl.gameObject);
                    //        _terminalStart = terminalCtrl;
                    //    }
                    //}
                    #endregion

                    //设置接线端子脚本
                    terminalCtrl.InsertLightState(false);   
                    _terminalStart = terminalCtrl;
                    if (AppManagement.Instance._TrainExam == EnumCtrl.Model.Exam)
                    {
                        //  Debug.Log("考核模式调用这个");
                    }
                    else
                    {
                        //  Debug.Log("练习，教学模式调用这个");
                        SetCurrentIndexAdd();
                        SetCurrentTerminalCtrl();
                    }
                }
                #endregion
            }
            else
            {
                string sameLineID = _terminalStart._CurTerminalData._LinesID[0];
                if (TwoTerminalConnectable(_terminalStart, terminalCtrl, ref sameLineID))
                {
                    _terminalStart._ConnectErrorNumber = 0;
                }
                else
                {
                    _terminalStart._ConnectErrorNumber++;
                }
                terminalCtrl.InsertLightState(_terminalStart._ConnectErrorNumber == 0);
                if (_terminalStart._ConnectErrorNumber == 0)
                {
                    //手动连接成功

                    TerminalsConnect(_terminalStart, terminalCtrl, sameLineID);
                    AddScore(sameLineID);
                    _terminalStart = null;
                    _chaTouTemp = null;
                    CheckAllTerminalConnect();

                    //增加索引,调用闪烁UI和和闪烁端子
                    //智能运动 
                    if (AppManagement.Instance._CurType == EnumCtrl.Type.ZNYD)
                    {
                        if (AppManagement.Instance._TrainExam == EnumCtrl.Model.Exam)
                        {
                            Debug.Log("考核模式调用这个");
                        }
                        else
                        {
                            Debug.Log("练习，教学模式调用这个");
                            SetCurrentIndexAdd();
                            SetCurrentTerminalCtrl();
                        }
                    }

                    //增加索引,调用闪烁UI和和闪烁端子
                    //搬运输送
                    if (AppManagement.Instance._CurType == EnumCtrl.Type.BYSS)
                    {
                        if (AppManagement.Instance._TrainExam == EnumCtrl.Model.Exam)
                        {
                            //Debug.Log("考核模式调用这个");
                        }
                        else
                        {
                            //  Debug.Log("练习，教学模式调用这个");
                            SetCurrentIndexAdd();
                            //增加提示索引,步骤提示
                            var v = UI_Manage.Instance.GetPanel("ConnectPanel").GetComponent<ConnectPanel>();
                            v.AddByssIndex();
                            v.SetByssLineTip();
                            SetCurrentTerminalCtrl();
                            //配音播放
                            var a = UI_Manage.Instance.GetPanel("PracticeAndExamPanel").GetComponent<PracticeAndExamPanel>();
                            if (a._CurTrainExamSceneCtrl.speakManager != null)
                            {
                                a._CurTrainExamSceneCtrl.speakManager.AddAudioCilp();
                                a._CurTrainExamSceneCtrl.speakManager.PlayAudioCilp();
                            }


                        }
                    }

                    //剩下三个模式
                    if (AppManagement.Instance._CurType == EnumCtrl.Type.CLFJ||
                        AppManagement.Instance._CurType == EnumCtrl.Type.QDCY||
                        AppManagement.Instance._CurType == EnumCtrl.Type.XHBY
                        ) {

                        if (AppManagement.Instance._TrainExam == EnumCtrl.Model.Exam) {

                            Debug.Log("考核调用这个");
                        }
                        else
                        {
                            Debug.Log("练习，教学模式调用这个");
                            SetCurrentIndexAdd();
                            SetCurrentTerminalCtrl();
                        }



                    }

                }
                else
                {//手动连接成功                    
                    PopUpMng.PopCustomFailToast("操作错误", "请根据端子分配表及接线图正确接线", "确认", () =>
                    {
                        //练习模式
                        if (_terminalStart && _terminalStart._ConnectErrorNumber >= 3 && AppManagement.Instance._TrainExam == EnumCtrl.Model.Train)
                        {
                            //将正确接线
                            if (AutoInsertChaTou(_terminalStart))
                            {
                                _terminalStart._ConnectErrorNumber = 0;
                                _terminalStart = null;
                                _chaTouTemp = null;
                                CheckAllTerminalConnect();
                            }
                            else
                            {
                                DestoryChaTou();
                            }
                        }
                        //教学模式
                        if (_terminalStart && _terminalStart._ConnectErrorNumber >= 3 && AppManagement.Instance._TrainExam == EnumCtrl.Model.Teach)
                        {
                            //将正确接线
                            if (AutoInsertChaTou(_terminalStart))
                            {
                                _terminalStart._ConnectErrorNumber = 0;
                                _terminalStart = null;
                                _chaTouTemp = null;
                                CheckAllTerminalConnect();
                            }
                            else
                            {
                                DestoryChaTou();
                            }
                        } //考核模式
                        if (AppManagement.Instance._TrainExam == EnumCtrl.Model.Exam)
                        {

                            DestoryChaTou();
                        }

                    });
                }
            }


        }
        /// <summary>
        /// 自动接线
        /// </summary>
        private void AutoLineCall(object sender, System.EventArgs e)
        {
            AutoLine();
            CheckAllTerminalConnect();
        }

        [SerializeField, Header("接线表所需要的端子脚本")]
        List<TerminalCtrl> terminalCtrls = new List<TerminalCtrl>();

        [SerializeField, Header("本次实验所有的端子脚本")]
        List<TerminalCtrl> AllterminalCtrls = new List<TerminalCtrl>();

        [Header("当前可以操作的端子")]
        public int CurrentIndex = 0;

        [SerializeField, Header("UI闪烁和相机位置组")]
        public List<string> CameraOrUIStrs = new List<string>() { };

        [SerializeField, Header("连线事件组")]
        public List<LineEvent> AlllineEvents;

        [Header("智能运动相机侧视角")]
        public GameObject ZNYD_Ce_View;
        [Header("搬运输送相机视角")]
        public GameObject Byss_Camera1;
        public GameObject Byss_Camera2;
        /// <summary>
        /// 获取本次接线要用到的端子
        /// 获取这个预制体要用到的端子
        /// </summary>
        public void GetAllTerminalCtrl()
        {


            ///这个循环是找到表中连接的端子
            for (int i = 0; i < _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)].Count; i++)
            {

                TerminalModel[][] terminals = _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)][i];




                for (int j = 0; j < terminals.Length; j++)
                {

                    if (terminals[j] != null)
                    {


                        for (int k = 0; k < terminals[j].Length; k++)
                        {


                            TerminalCtrl terminal1 = terminals[j][k]._TerminalGeo.GetComponent<TerminalCtrl>();
                            terminalCtrls.Add(terminal1);


                        }

                    }

                }



            }

            ///这个循环是找到预制体下所有的端子
            var Scene_terminalCtrls = transform.GetComponentsInChildren<TerminalCtrl>();

            for (int i = 0; i < Scene_terminalCtrls.Length; i++)
            {
                AllterminalCtrls.Add(Scene_terminalCtrls[i]);
            }
            if (AppManagement.Instance._CurType == EnumCtrl.Type.ZNYD)
            {
                //生成对应表中连接端子的相机或者UI 事件
                CameraOrUIStrs = new List<string>() {
                //0-9
    "前","后",
     "前","后",
     "前","后",
     "前","后",
     "前","后",


     //10-19
     "前","后",
     "前","前",
     "前","后",
     "前","后",
     "前","后",

     //20-29
     "前","后",
     "前","前",
     "前","后1",
     "前1","侧",
     "前1","侧",

       //30-39
      "前1","侧",
      "前1","后1",
      "前1","后1",
      "前","无",
      "无","无",

        //40-51
      "无","无",
      "无","无",
      "前","后",
      "前","无",
      "无","后",
      "后1","前"
            };

            }
            if (AppManagement.Instance._CurType == EnumCtrl.Type.BYSS)
            {
                CameraOrUIStrs = new List<string>() {
                //0-9
    "Camera1","Camera1",
     "Camera1","Camera1",
     "Camera1","Camera1",
     "Camera1","Camera1",
     "Camera1","Camera1",
     //10-15
     "Camera1","Camera1",
     "Camera2","Camera2",
     "Camera2","Camera2",
     //16-20
     "Camera2","Camera2",
     "Camera2","Camera2",
     "Camera2","Camera2",
     "Camera2","Camera2",
            };
            }
            if (AppManagement.Instance._CurType == EnumCtrl.Type.CLFJ) {
                //材料分拣 45个
                CameraOrUIStrs = new List<string>()
                {
                    "无","无","无","无","无",    "无","无","无","无","无",
                    "无","无","无","无","无",    "无","无","无","无","无",
                    "无","无","无","无","无",    "无","无","无","无","无",
                    "无","无","无","无","无",    "无","无","无","无","无",

                    "无","无","无","无","无"

                };

                }
            if (AppManagement.Instance._CurType == EnumCtrl.Type.XHBY ) {

                //循环搬运机械手 66个
                CameraOrUIStrs = new List<string>()
                {
                  "无","无","无","无","无",    "无","无","无","无","无",
                    "无","无","无","无","无",    "无","无","无","无","无",
                    "无","无","无","无","无",    "无","无","无","无","无",
                    "无","无","无","无","无",    "无","无","无","无","无",
                    "无","无","无","无","无",   "无","无","无","无","无",
                    "无","无","无","无","无",   "无","无","无","无","无",
                    "无","无","无","无","无",   "无",

                };

            }
            if (AppManagement.Instance._CurType == EnumCtrl.Type.QDCY )
               
            {
                // 气动冲压 30个
                CameraOrUIStrs = new List<string>() {
                "无","无","无","无","无",    "无","无","无","无","无",
                    "无","无","无","无","无",    "无","无","无","无","无",
                    "无","无","无","无","无",    "无","无","无","无","无"
                    };

            }

            ///添加进对应的事件组
            for (int j = 0; j < terminalCtrls.Count; j++)
            {
                int num = j;

                LineEvent _lineEvent = new LineEvent();
                _lineEvent.terminalCtrl = terminalCtrls[num];
                _lineEvent.CameraOrUI = CameraOrUIStrs[num];
                AlllineEvents.Add(_lineEvent);

            }



        }

        /// <summary>
        ///获取当前要显示的端子
        ///关掉除了当前端子的其他端子碰撞体
        /// 关掉当前场景所有端子的端子碰撞体
        ///  /// <summary>
        public void SetCurrentTerminalCtrl()
        {
            //关掉其他端子碰撞体,和泛光
            //for (int i = 0; i < AlllineEvents.Count; i++)
            //{
            //    var colliders = AlllineEvents[i].terminalCtrl.transform.GetComponents<Collider>();

            //    for (int h = 0; h < colliders.Length; h++)
            //    {
            //        colliders[h].enabled = false;



            //    }


            //    AlllineEvents[i].terminalCtrl.HideHighlightOutLine();
            //}

            //关掉场景中所有接线端子碰撞器
            for (int i = 0; i < AllterminalCtrls.Count; i++)
            {
                AllterminalCtrls[i].HideHighlightOutLine();
                var colliders = AllterminalCtrls[i].transform.GetComponents<Collider>();

                for (int h = 0; h < colliders.Length; h++)
                {
                    colliders[h].enabled = false;



                }
            }


            //获取ConnetPanel，然后进行设置
            var v = UI_Manage.Instance.GetPanel("ConnectPanel").GetComponent<ConnectPanel>();
            //结束
            if (CurrentIndex == AlllineEvents.Count)
            {

                for (int i = 0; i < AlllineEvents.Count; i++)
                {
                    //关闭所有闪光，碰撞体
                    var colliders = AlllineEvents[i].terminalCtrl.GetComponents<Collider>();

                    for (int h = 0; h < colliders.Length; h++)
                    {
                        colliders[h].enabled = false;



                    }

                    AlllineEvents[i].terminalCtrl.HideHighlightOutLine();
                }
                //关闭闪烁UI
                v.HideRedImage();
            }
            else
            {

                //继续增加
                switch (AlllineEvents[CurrentIndex].CameraOrUI)
                {
                    case "前":
                        v.ShowRedImage(0);

                        break;
                    case "后":
                        v.ShowRedImage(2);
                        break;
                    case "前1":
                        v.ShowRedImage(1);

                        break;
                    case "后1":
                        v.ShowRedImage(3);
                        break;

                    case "侧":
                        //相机右侧视角
                        Camera.main.GetComponent<CameraControl>().enabled = false;
                        Camera.main.transform.position = ZNYD_Ce_View.transform.position;
                        Camera.main.transform.localEulerAngles = ZNYD_Ce_View.transform.localEulerAngles;
                        Camera.main.GetComponent<CameraControl>().enabled = true;

                        //当前要点击的端子碰撞体打开
                        var colliders = AlllineEvents[CurrentIndex].terminalCtrl.GetComponents<Collider>();
                        for (int i = 0; i < colliders.Length; i++)
                        {
                            colliders[i].enabled = true;
                        }

                        AlllineEvents[CurrentIndex].terminalCtrl.ShowHighlightOutLine();
                        break;

                    case "无":

                        //当前端子设置碰撞体
                        AlllineEvents[CurrentIndex].terminalCtrl.ShowHighlightOutLine();
                        var col = AlllineEvents[CurrentIndex].terminalCtrl.GetComponents<Collider>();
                        for (int i = 0; i < col.Length; i++)
                        {
                            col[i].enabled = true;
                        }

                  
                        break;
                    //相机1
                    case "Camera1":

                        //搬运输送相机视角1
                        Camera.main.GetComponent<CameraControl>().enabled = false;
                        Camera.main.transform.position = Byss_Camera1.transform.position;
                        Camera.main.transform.rotation = Byss_Camera1.transform.rotation;
                        Camera.main.GetComponent<CameraControl>().enabled = true;

                        //当前端子设置碰撞体
                        var colliders2 = AlllineEvents[CurrentIndex].terminalCtrl.GetComponents<Collider>();
                        for (int i = 0; i < colliders2.Length; i++)
                        {
                            colliders2[i].enabled = true;
                        }

                        AlllineEvents[CurrentIndex].terminalCtrl.ShowHighlightOutLine();
                        break;
                    //相机2
                    case "Camera2":
                        //搬运输送相机视角2
                        Camera.main.GetComponent<CameraControl>().enabled = false;
                        Camera.main.transform.position = Byss_Camera2.transform.position;
                        Camera.main.transform.rotation = Byss_Camera2.transform.rotation;
                        Camera.main.GetComponent<CameraControl>().enabled = true;

                        //当前端子设置碰撞体
                        var colliders1 = AlllineEvents[CurrentIndex].terminalCtrl.GetComponents<Collider>();
                        for (int i = 0; i < colliders1.Length; i++)
                        {
                            colliders1[i].enabled = true;
                        }

                        AlllineEvents[CurrentIndex].terminalCtrl.ShowHighlightOutLine();
                        break;


                }
            }



        }

        /// <summary>
        /// 当前索引增加
        /// </summary>
        public void SetCurrentIndexAdd()
        {



            if (CurrentIndex < AlllineEvents.Count)
            {

                CurrentIndex++;

            }
            else
            {
                Debug.Log("结束。不再增加");
                //   CurrentIndex = AlllineEvents.Count;
            }






        }


        /// <summary>
        /// 设置当前索引的UI是否点击完成
        /// </summary>
        public void SetCurrentUIorCameraBool()
        {
            var v = UI_Manage.Instance.GetPanel("ConnectPanel").GetComponent<ConnectPanel>();
            //当前要点击的端子闪烁
            AlllineEvents[CurrentIndex].terminalCtrl.ShowHighlightOutLine();
            //当前要点击的端子碰撞体打开
            var col = AlllineEvents[CurrentIndex].terminalCtrl.GetComponents<Collider>();
            for (int i = 0; i < col.Length; i++)
            {
                col[i].enabled = true;
            }

            v.HideRedImage();
        }


        /// <summary>
        ///点击按钮结束接线
        /// </summary>
        public void FinishTerminalCtrl() {


            //关闭所有端子的碰撞体，与闪光识别
            for (int i = 0; i < AlllineEvents.Count; i++)
            {
             
                var colliders = AlllineEvents[i].terminalCtrl.GetComponents<Collider>();

                for (int h = 0; h < colliders.Length; h++)
                {
                    colliders[h].enabled = false;



                }

                AlllineEvents[i].terminalCtrl.HideHighlightOutLine();
            }
            //关闭闪烁UI
            bool isHave = UI_Manage.Instance.GetPanel("ConnectPanel");
            if (isHave)
            {
                var v = UI_Manage.Instance.GetPanel("ConnectPanel").GetComponent<ConnectPanel>();
                v.HideRedImage();
            }
            else
            {

            }
          

        }


        /// <summary>
        /// 导航栏直接调用接线
        /// </summary>
        public void AutoLine()
        {
            DestoryChaTou();
            AutoInsertChaTou(null);
            FinishTerminalCtrl();
        }




        /// <summary>
        /// 销毁连接错误的线
        /// </summary>
        private void DestoryChaTou()
        {
            if (_terminalStart)
            {
                if (AppManagement.Instance._CurType == EnumCtrl.Type.XHBY ||
                    AppManagement.Instance._CurType == EnumCtrl.Type.QDCY ||
                    AppManagement.Instance._CurType == EnumCtrl.Type.ZNYD   )
                {
                    Destroy(_chaTouTemp);
                    DestroyImmediate(_chatou0.gameObject);
                    _terminalStart._ConnectErrorNumber = 0;
                    _terminalStart.ChaTouNumber(false);
                    _terminalStart = null;
                    _chatou0 = null;
                    _chaTouTemp = null;
                }
                else if (AppManagement.Instance._CurType == EnumCtrl.Type.CLFJ )
                {
                    _terminalStart.RecallStraightChaTouPos();
                    _terminalStart = null;
                } 
                else if (AppManagement.Instance._CurType == EnumCtrl.Type.BYSS) {


                    _terminalStart = null;

                }
            }
        }
        /// <summary>
        /// 自动将插头插入端子
        /// 如果不是全部插入，则直插入当前所持有第一个端子对应的线路的关联端子
        /// 如果全部插入，则将剩余的全部插入
        /// </summary>
        /// <param name="terminal">如果全部自动插入，此处为null</param>
        /// <returns>返回一次自动生成时是否成功</returns>
        private bool AutoInsertChaTou(TerminalCtrl terminal)
        {
            bool isInsert = false;
            if (terminal)
            {
                List<string> linesIndex = new List<string>(terminal._CurTerminalData._LinesID);
                //筛选出所有与已持有的开始端子相关的线路
                List<TerminalModel[][]> linesTemp = new List<TerminalModel[][]>();
                List<TerminalModel[][]> linesSrc = _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)];
                for (int i = 0; i < linesIndex.Count; i++)
                {
                    linesTemp.Add(linesSrc[int.Parse(linesIndex[i]) - 1]);
                }

                for (int i = 0; i < linesTemp.Count; i++)
                {
                    TerminalModel[][] terminals = linesTemp[i];
                    for (int a = 0; a < terminals.GetLength(0); a++)
                    {
                        if (terminals[a] != null)
                        {
                            for (int b = 0; b < terminals[a].Length; b++)
                            {
                                if (AutoItemCon(terminal, terminals)) return true;
                            }
                        }
                    }
                }
            }
            else
            {
                for (int i = 0; i < _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)].Count; i++)
                {
              TerminalModel[][] terminals = _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)][i];
                

                    //_lineConnectData.
                    //foreach (var item in _lineConnectData._TerminalDic["循环搬运机械手虚拟仿真系统"])
                    //{
                       
                    //}

                    for (int a = 0; a < terminals.GetLength(0); a++)
                    {
                        if (terminals[a] != null)
                        {
                            for (int b = 0; b < terminals[a].Length; b++)
                            {
                                Debug.Log("!!!!!!!!!!!!" + terminals[a][b]._TerminalGeo.name);

                                TerminalCtrl terminal1 = terminals[a][b]._TerminalGeo.GetComponent<TerminalCtrl>();
                                //如果是材料分拣，有几个特殊端子
                                if (AppManagement.Instance._CurType == EnumCtrl.Type.CLFJ && (
                                    terminal1._CurTerminalData._TerminalName.Equals("DLB0.3") ||
                                    terminal1._CurTerminalData._TerminalName.Equals("DLB0.4") ||
                                    terminal1._CurTerminalData._TerminalName.Equals("DLB0.5")))
                                {
                                    if (terminal1._CurTerminalData._ConnectGeos.Count < 1)
                                    {
                                        terminal1.StraightSetChaTouPos();
                                        terminal1._CurTerminalData._ConnectGeos.Add(terminal1.gameObject);
                                    }
                                }
                                //如果是搬运输送，有几个特殊端子
                                else if (AppManagement.Instance._CurType == EnumCtrl.Type.BYSS)
                                {
                                    if (terminal1._CurTerminalData._ConnectGeos.Count < 1)
                                    {
                                        terminal1.StraightSetChaTouPos_Rightaway();
                                        terminal1._CurTerminalData._ConnectGeos.Add(terminal1.gameObject);
                                    }
                                }
                                else
                                {
                                    AutoItemCon(terminals[a][b]._TerminalGeo.GetComponent<TerminalCtrl>(), terminals);
                                }
                            }
                        }
                    }
                }
            }
            return isInsert;
        }

        /// <summary>
        /// 寻找可自动相连的端子，并连接
        /// </summary>
        /// <param name="terminal"></param>
        /// <param name="terminals"></param>
        /// <returns></returns>
        private bool AutoItemCon(TerminalCtrl terminal, TerminalModel[][] terminals)
        {
            for (int c = 0; c < terminals.GetLength(0); c++)
            {
                if (terminals[c] != null)
                {
                    for (int d = 0; d < terminals[c].Length; d++)
                    {
                        string sameLineID = terminal._CurTerminalData._LinesID[0];
                        if (TwoTerminalConnectable(terminal, terminals[c][d]._TerminalGeo.GetComponent<TerminalCtrl>(), ref sameLineID))
                        {
                            TerminalsConnect(terminal._CurTerminalData._TerminalGeo.GetComponent<TerminalCtrl>(),
                                 terminals[c][d]._TerminalGeo.GetComponent<TerminalCtrl>(), sameLineID);
                            return true;
                        }
                    }
                }
            }
            return false;
        }


        /// <summary>
        /// 两个端子相连
        /// _terminalStart不为null,则只能进行几次，否则需要每次为_terminalStart赋值
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        private bool TerminalsConnect(TerminalCtrl a, TerminalCtrl b, string sameLineID)
        {
            Debug.Log("线段:" + sameLineID + "——" + a.name + "_连_" + b.name);
            if (AppManagement.Instance._CurType == EnumCtrl.Type.XHBY ||
                    AppManagement.Instance._CurType == EnumCtrl.Type.QDCY)
            {
                if (_terminalStart == null)
                {
                    _chaTouTemp = Instantiate(_chatouPrefab, _chatouContain);
                    _chatou0 = _chaTouTemp.transform.Find("ChaTou0");
                    a.SetChaTouPos(_chatou0);
                }
                a._CurTerminalData._ConnectGeos.Add(b.gameObject);

                b._CurTerminalData._ConnectGeos.Add(a.gameObject);
                Transform chatou1 = _chaTouTemp.transform.Find("ChaTou1");
                b.SetChaTouPos(chatou1);
                temp = _chaTouTemp;
                //生成线段柔化
                Transform line = temp.transform.Find("Line");
                Transform line2 = temp.transform.Find("Line2");
                Transform midPoint = temp.transform.Find("MidPoint");
                Transform startPoint = line.GetComponent<BezierPipe>().point1;
                Transform endPoint = line2.GetComponent<BezierPipe>().point2;
                Vector3 lowPoint;
                Vector3 highPoint;
                if (startPoint.position.y > endPoint.position.y)
                {
                    lowPoint = endPoint.position;
                    highPoint = startPoint.position;
                }
                else
                {
                    lowPoint = startPoint.position;
                    highPoint = endPoint.position;
                }
                Debug.Log(Vector3.Distance(lowPoint, highPoint));
                if (Vector3.Distance(lowPoint, highPoint) < 1.0f)
                {
                    midPoint.position = new Vector3(
                    0.5f * lowPoint.x + (1 - 0.5f) * highPoint.x,
                    0.5f * lowPoint.y + (1 - 0.5f) * highPoint.y,
                    0.5f * lowPoint.z + (1 - 0.5f) * highPoint.z
                    );
                }
                else
                {
                    //位置比例
                    //小部分在低处
                    midPoint.position = new Vector3(
                        posx * lowPoint.x + (1 - posx) * highPoint.x,
                        posy * lowPoint.y + (1 - posy) * highPoint.y,
                        posz * lowPoint.z + (1 - posz) * highPoint.z
                        );
                    //旋转比例
                    //小部分在高处
                    //Vector3 rotTargPoint = new Vector3(
                    //    rotx * highPoint.x + (1 - rotx) * highPoint.x,
                    //    roty * lowPoint.y + (1 - roty) * highPoint.y,
                    //    rotz * highPoint.z + (1 - rotz) * highPoint.z
                    //    );
                }
                midPoint.LookAt(startPoint, Vector3.up);

                line.GetComponent<HighlightingSystem.Highlighter>().tween = true;
                line2.GetComponent<HighlightingSystem.Highlighter>().tween = true;
                line.GetComponent<BezierPipe>().update = true;
                line2.GetComponent<BezierPipe>().update = true;
                float formTime = 0.0f;
                DOTween.To(() => formTime, x => x = formTime, 0.5f, 0.5f).OnComplete(() =>
                {
                    line.GetComponent<BezierPipe>().update = false;
                    line2.GetComponent<BezierPipe>().update = false;
                });


                //line.SetParent(_chatouContain);
                //line.GetComponent<HighlightingSystem.Highlighter>().tween = true;
                //line.GetComponent<BezierPipe>().update = true;
                //float formTime = 0.0f;
                //DOTween.To(() => formTime, x => x = formTime, 0.5f, 0.5f).OnComplete(() =>
                //{
                //    line.GetComponent<BezierPipe>().update = false;
                //});
                //Destroy(_chaTouTemp);
            }
            else if (AppManagement.Instance._CurType == EnumCtrl.Type.CLFJ)
            {
                if (a != _terminalStart)
                {
                    a.StraightSetChaTouPos();
                }
                if (b != _terminalStart)
                {
                    b.StraightSetChaTouPos();
                }
                a._CurTerminalData._ConnectGeos.Add(b.gameObject);
                b._CurTerminalData._ConnectGeos.Add(a.gameObject);

            }
            else if (AppManagement.Instance._CurType == EnumCtrl.Type.ZNYD)
            {
                string lineName = sameLineID;
                if (sameLineID.Equals("22") || sameLineID.Equals("23"))
                {
                    string terminalStart = a._CurTerminalData._TerminalName;
                    string terminalEnd = b._CurTerminalData._TerminalName;
                    string[] temp = new string[] { "ET2", "ET3", "WLSSQ", "CXKG" };
                    for (int i = 0; i < temp.Length; i++)
                    {
                        if (terminalStart.Contains(temp[i]))
                        {
                            lineName = $"{sameLineID}({terminalStart},{terminalEnd})";
                            break;
                        }
                        if (terminalEnd.Contains(temp[i]))
                        {
                            lineName = $"{sameLineID}({terminalEnd},{terminalStart})";
                            break;
                        }
                    }
                }
                if (!string.IsNullOrEmpty(lineName))
                {
                    _ZNYDLines[lineName].SetActive(true);
                }
                if (_terminalStart)
                {
                    DestroyImmediate(_chatou0.gameObject);
                    Destroy(_chaTouTemp);
                }

                a._CurTerminalData._ConnectGeos.Add(b.gameObject);
                b._CurTerminalData._ConnectGeos.Add(a.gameObject);
            }
            //搬运输送设置插头模式 
            else if (AppManagement.Instance._CurType == EnumCtrl.Type.BYSS)
            {


                Debug.Log(a.gameObject.name + "!!!!!!!!!!!!!!!!!!");
                Debug.Log(b.gameObject.name + "!!!!!!!!!!!!!!!!!!");

                a.StraightSetChaTouPos();
                b.StraightSetChaTouPos();
                a._CurTerminalData._ConnectGeos.Add(b.gameObject);
                b._CurTerminalData._ConnectGeos.Add(a.gameObject);
            }
            SyncTerminalInfo(a);
            SyncTerminalInfo(b);
            return true;
        }

        /// <summary>
        /// 判断此端子是否在当前系统数据中
        /// </summary>
        /// <param name="TerminalName"></param>
        /// <returns></returns>
        private bool TerminalInData(string TerminalName)
        {
            bool isInclude = false;
            for (int i = 0; i < _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)].Count; i++)
            {
                TerminalModel[][] terminals = _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)][i];
                for (int a = 0; a < terminals.GetLength(0); a++)
                {
                    if (terminals[a] != null)
                    {
                        for (int b = 0; b < terminals[a].Length; b++)
                        {
                            if (terminals[a][b]._TerminalGeo.name.Equals(TerminalName))
                            {
                                isInclude = true;
                                break;
                            }
                        }
                    }
                }
            }
            return isInclude;
        }

        /// <summary>
        /// 两个端子必须满足所有条件，才可以相连
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <param name="sameLineID"></param>
        /// <returns></returns>
        private bool TwoTerminalConnectable(TerminalCtrl a, TerminalCtrl b, ref string sameLineID)
        {
            if (!b._CurTerminalData._TerminalName.Equals(a._CurTerminalData._TerminalName) &&//不能连自身
                            !b._CurTerminalData._ConnectGeos.Contains(a._CurTerminalData._TerminalGeo))//连过的不连
            {
                //是否有相同LineID
                bool sameline = TerminalsSameLine(a, b._CurTerminalData._TerminalGeo.GetComponent<TerminalCtrl>(), out List<string> sameLines);
                if (sameline)
                {
                    sameLineID = sameLines[0];//同一模块端子之间和不同模块之间不存在并联，所以只会有一个相同的
                    ////不要链接为一个环
                    //bool isLoop = CheckTerminalLoop(a, b._CurTerminalData._TerminalGeo.GetComponent<TerminalCtrl>(), sameLineID);
                    //if (!isLoop)
                    //{
                        ////两个控制面板只允许有一条线
                        //bool ctrlTwo = CtrlConnect(a, b._CurTerminalData._TerminalGeo.GetComponent<TerminalCtrl>(), sameLineID);
                        //if (ctrlTwo)
                        //{
                            //一个控制板内必须串联
                            bool bunchInCtrl = BunchInCtrl(a, b._CurTerminalData._TerminalGeo.GetComponent<TerminalCtrl>(), sameLineID);
                            if (bunchInCtrl)
                            {
                                return true;
                            }
                       // }
                //    }
                }
            }
            return false;
        }

        /// <summary>
        /// 两个端子是否属于同一条线
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        private bool TerminalsSameLine(TerminalCtrl a, TerminalCtrl b, out List<string> sameLinesID)
        {
            bool sameLine = false;
            sameLinesID = new List<string>();
            for (int i = 0; i < a._CurTerminalData._LinesID.Count; i++)
            {
                for (int j = 0; j < b._CurTerminalData._LinesID.Count; j++)
                {
                    if (a._CurTerminalData._LinesID[i].Equals(b._CurTerminalData._LinesID[j]))
                    {//判断是否有相同的LineID
                        sameLine = true;
                        sameLinesID.Add(a._CurTerminalData._LinesID[i]);
                    }
                }
            }
            return sameLine;
        }

        /// <summary>
        /// 是否形成环
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns>形成环</returns>
        private bool CheckTerminalLoop(TerminalCtrl a, TerminalCtrl b, string sameLineID)
        {
            bool isLoop = TerminalConnectChildren(a, null, b, sameLineID);
            return isLoop;
        }
        /// <summary>
        /// DFS遍历某个端子的所有子物体,查看是否形成环形
        /// </summary>
        /// <param name="a">需要遍历的端子</param>
        /// <param name="previous">遍历当前端子时的上一个端子，防止出现重复遍历</param>
        /// <param name="target">需要匹配的目标端子</param>
        /// <param name="lineID">需要查询的线段ID</param>
        /// <returns>遍历到和目标相同端子，说明会形成环形，则返回false,</returns>
        private bool TerminalConnectChildren(TerminalCtrl a, TerminalCtrl previous, TerminalCtrl target, string lineID)
        {
            bool loop = false;
            if (a == target)
            {
                return true;
            }
            if (a._CurTerminalData._ConnectGeos.Count > 0)
            {
                foreach (GameObject item in a._CurTerminalData._ConnectGeos)
                {
                    if (item.GetComponent<TerminalCtrl>()._CurTerminalData._LinesID.Contains(lineID))
                    {
                        if (previous == null || (previous != null && item != previous.gameObject))
                        {
                            loop = TerminalConnectChildren(item.GetComponent<TerminalCtrl>(), a, target, lineID);
                            if (loop) return true;
                        }
                    }
                }
            }
            return loop;
        }

        /// <summary>
        /// 两个端子相连，查看是否属于两个控制板，
        /// 两个控制板的只允许有一条连接线
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns>两个点可连接</returns>
        private bool CtrlConnect(TerminalCtrl a, TerminalCtrl b, string sameLineID)
        {
            bool isConnect = false;
            string aCtrlName = a._CurTerminalData._CtrlBoard;
            string bCtrlName = b._CurTerminalData._CtrlBoard;
            if (aCtrlName.Equals(bCtrlName)) return true;//同一控制板可以直接通过此处
            //不同控制板时候，需要有一个控制板没连过线
            if (_lineCtrlDic[sameLineID].Contains(aCtrlName) || _lineCtrlDic[sameLineID].Contains(bCtrlName))
            {
                for (int i = 0; i < _lineCtrlDic[sameLineID].Count; i++)
                {
                    if (aCtrlName.Equals(_lineCtrlDic[sameLineID][i]))
                    {
                        _lineCtrlDic[sameLineID].RemoveAt(i);
                        isConnect = true;
                        i--;
                    }
                    if (i >= 0 && bCtrlName.Equals(_lineCtrlDic[sameLineID][i]))
                    {
                        _lineCtrlDic[sameLineID].RemoveAt(i);
                        isConnect = true;
                        i--;
                    }
                }
            }
            return isConnect;
        }
        /// <summary>
        /// 每个线段有多少控制板数据存储起来
        /// </summary>
        private void GetCtrlTerminals()
        {
            for (int i = 0; i < _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)].Count; i++)
            {
                TerminalModel[][] terminals = _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)][i];
                List<string> ctrls = new List<string>();
                for (int a = 0; a < terminals.GetLength(0); a++)
                {
                    if (terminals[a] != null)
                    {
                        ctrls.Add(terminals[a][0]._CtrlBoard);
                    }
                }
                if (!_lineCtrlDic.ContainsKey((i + 1).ToString()))
                {
                    _lineCtrlDic.Add((i + 1).ToString(), ctrls);
                }
            }
        }

        /// <summary>
        /// 保证一个控制板内所有端子是串联
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns>两个端子可连</returns>
        private bool BunchInCtrl(TerminalCtrl aTerminal, TerminalCtrl bTerminal, string sameLineID)
        {
            int terminalConNumber = 0;//两个端子都需要验证
            foreach (GameObject item in aTerminal._CurTerminalData._ConnectGeos)
            {
                if (aTerminal._CurTerminalData._CtrlBoard.Equals(bTerminal._CurTerminalData._CtrlBoard) &&//准备相连的两个属于同一个控制器
                    aTerminal._CurTerminalData._CtrlBoard.Equals(item.GetComponent<TerminalCtrl>()._CurTerminalData._CtrlBoard) &&//验证端子所连接的为同一个控制板的才计入其中
                    item.GetComponent<TerminalCtrl>()._CurTerminalData._LinesID.Contains(sameLineID))//验证端子所连接的同时也是同一条线段的才计入其中
                {
                    terminalConNumber++;
                }
            }
            if (terminalConNumber < 2)
            {
                terminalConNumber = 0;
                foreach (GameObject item in bTerminal._CurTerminalData._ConnectGeos)
                {
                    if (bTerminal._CurTerminalData._CtrlBoard.Equals(aTerminal._CurTerminalData._CtrlBoard) &&//准备相连的两个属于同一个控制器
                        bTerminal._CurTerminalData._CtrlBoard.Equals(item.GetComponent<TerminalCtrl>()._CurTerminalData._CtrlBoard) &&//验证端子所连接的为同一个控制板的才计入其中
                        item.GetComponent<TerminalCtrl>()._CurTerminalData._LinesID.Contains(sameLineID))//验证端子所连接的同时也是同一条线段的才计入其中
                    {
                        terminalConNumber++;
                    }
                }
            }
            if (terminalConNumber < 2)
            {//如果存在相同线路端子数量都小于2的就可以连接，多余2的端子说明存在串联
                return true;
            }
            return false;
        }

        /// <summary>
        /// 同步端子信息，防止有的端子在不同线段中，信息无法同步问题
        /// </summary>
        private void SyncTerminalInfo(TerminalCtrl terminal)
        {
            Dictionary<TerminalCtrl, int> terminalLineDic = new Dictionary<TerminalCtrl, int>();
            for (int i = 0; i < _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)].Count; i++)
            {
                TerminalModel[][] terminals = _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)][i];
                for (int a = 0; a < terminals.GetLength(0); a++)
                {
                    if (terminals[a] != null)
                    {
                        for (int b = 0; b < terminals[a].Length; b++)
                        {
                            if (terminals[a][b]._TerminalGeo.GetComponent<TerminalCtrl>() == terminal)
                            {
                                terminals[a][b] = terminal._CurTerminalData;
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 检查所有端子是否都连接完毕
        /// </summary>
        private void CheckAllTerminalConnect()
        {
            //判断每个端子有多少线段
            Dictionary<TerminalCtrl, int> terminalLineDic = new Dictionary<TerminalCtrl, int>();
            for (int i = 0; i < _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)].Count; i++)
            {
                TerminalModel[][] terminals = _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)][i];
                for (int a = 0; a < terminals.GetLength(0); a++)
                {
                    if (terminals[a] != null)
                    {
                        for (int b = 0; b < terminals[a].Length; b++)
                        {
                            //考虑到一个端子可能涉及多条线路
                            if (terminalLineDic.ContainsKey(terminals[a][b]._TerminalGeo.GetComponent<TerminalCtrl>()))
                            {
                                terminalLineDic[terminals[a][b]._TerminalGeo.GetComponent<TerminalCtrl>()]++;
                            }
                            else
                            {
                                terminalLineDic.Add(terminals[a][b]._TerminalGeo.GetComponent<TerminalCtrl>(), 0);
                            }
                        }
                    }
                }
            }
            //连接后判断是否所有线路都链接完成
            bool allConnect = true;
            foreach (var item in terminalLineDic)
            {
                if (AppManagement.Instance._CurType == EnumCtrl.Type.CLFJ)
                {
                    if (item.Key._CurTerminalData._ConnectGeos.Count <= 0)
                    {
                        allConnect = false;
                        break;
                    }
                }
                else
                {
                    if (item.Key._CurTerminalData._ConnectGeos.Count <= item.Value)
                    {
                        allConnect = false;
                        break;
                    }
                }
            }
            if (allConnect)
            {
                PopUpMng.PopCustomSucToast("提示", "恭喜您成功完成设备所有接线", "程序调试", () =>
                {
                    CalculateScore();
                    AppManagement.Instance.ChangeModel(EnumCtrl.Model.Debug);
                    //音频设置
                    PracticeAndExamInSceneCtrl _practiceAndExamCtrl = UI_Manage.Instance.GetPanel("PracticeAndExamPanel")
              .GetComponent<PracticeAndExamPanel>()._CurTrainExamSceneCtrl;
                    //关闭声音组件
                    _practiceAndExamCtrl.speakManager.ChangeModelAudio("程序调试");
                     _practiceAndExamCtrl.speakManager.Init();


                });
            }
        }

        /// <summary>
        /// 计算得分
        /// 根据此线段总累计单位数是否等于此线段端子数量减一
        /// </summary>
        private void CalculateScore()
        {
            //计算得分
            for (int i = 0; i < _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)].Count; i++)
            {
                int terminalInLine = 0;
                TerminalModel[][] terminals = _lineConnectData._TerminalDic[EnumCtrl.GetEnumDescription(AppManagement.Instance._CurType)][i];
                for (int a = 0; a < terminals.GetLength(0); a++)
                {
                    if (terminals[a] != null)
                    {
                        if (AppManagement.Instance._CurType == EnumCtrl.Type.CLFJ)
                        {
                            if (terminals[a][0]._TerminalName.Equals("DLB0.3") ||
                                terminals[a][0]._TerminalName.Equals("DLB0.4") ||
                                terminals[a][0]._TerminalName.Equals("DLB0.5"))
                            {
                                terminalInLine += 2;
                            }
                            else
                            {
                                terminalInLine += terminals[a].Length;
                            }

                        }
                        else
                        {
                            terminalInLine += terminals[a].Length;
                        }
                    }
                }
                if (_connectLineDic.ContainsKey((i + 1).ToString()))
                {
                    if (_connectLineDic[(i + 1).ToString()] == terminalInLine - 1)
                    {//得分=此线段端子数量-1
                        AppManagement.Instance._ConnectScore += 3;
                    }
                }
            }
        }
        /// <summary>
        /// 此线段每次接通一个小线段，累加一个单位
        /// </summary>
        /// <param name="lineID"></param>
        private void AddScore(string lineID)
        {
            if (!string.IsNullOrEmpty(lineID))
            {
                if (_connectLineDic.ContainsKey(lineID))
                {
                    _connectLineDic[lineID]++;
                }
                else
                {
                    _connectLineDic.Add(lineID, 1);
                }
            }
        }
    }
}