using System.Collections;
using System.Collections.Generic;
using System.Threading.Tasks;
using DG.Tweening;
using GameFramework;
using GameFramework.Event;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.Serialization;
using UnityEngine.UI;
using UnityGameFramework.Runtime;

public class TrainStudyForm : UIFormLogic
{
    private GameObject _trainPanel;
    private GameObject _learnPanel;
    private GameObject _faultPanel;

    private GameObject _trainDoneTips;
    private GameObject _faultDoneTips;

    private Button _reStartButton;
    private Button _cpuButton;
    private Button _ramButton;
    private Button _fanButton;
    private Button _powerButton;
    private bool cpuDone = false;
    private bool fanDone = false;
    private bool ramDone = false;
    private bool powerDone = false;

    //private GameObject _overHotTips;
    private Button _reStarFaultButton;
    private Button _cpuFaultButton;
    private Button _ramFaultButton;
    private Button _fanFaultButton;
    private Button _powerFaultButton;
    private Button _hardDiskFaultButton;
    private Button _batteryFaultButton;

    private Image _cpuValueSlider;
    private Text _cpuValueText;
    private Image _ramValueSlider;
    private Text _ramValueText;
    private Slider _hardDiskTemperature;
    private Image _hardDiskColor;
    private Slider _mbTemperature;
    private Image _mbColor;
    private Slider _fanSpeed;

    public Sprite[] learnModelButtonImg;
    public Sprite[] trainModelButtonImg;
    public Sprite[] bugModelButtonImg;

    private Button _learnButton;
    private Button _trainButton;
    private Button _faultButton;

    private IT_TrainModelType _currentType;

    private GameObject messagePanel;
    private Text nameText;
    private Text messageText;

    private const string cpuMessage =
        "CPU一般指中央处理器。 中央处理器（Central Processing Unit，简称CPU）作为计算机系统的运算和控制核心，是信息处理、程序运行的最终执行单元。CPU自产生以来，在逻辑结构、运行效率以及功能外延上取得了巨大发展。";

    private const string ramMessage =
        "随机存取存储器，也叫主存，是与CPU直接交换数据的内部存储器。它可以随时读写（刷新时除外），而且速度很快，通常作为操作系统或其他正在运行中的程序的临时数据存储介质。RAM工作时可以随时从任何一个指定的地址写入（存入）或读出（取出）信息。它与ROM的最大区别是数据的易失性，即一旦断电所存储的数据将随之丢失。";

    private const string fanMessage =
        "用于机箱散热时：可沿机箱后面板排出热气流，使冷空气自前面板下部流入机箱。使机内形成持续对流的环境，降低机箱内环境温度，从而有效的达到辅助CPU、显卡等发热元件的散热。在用于电源散热时：除了带走电源内元件的热量，还可辅助排出机箱内热气流。";

    private const string powerMessage =
        "计算机属于弱电产品，也就是说部件的工作电压比较低，一般在正负12伏以内，并且是直流电。而普通的市电为220伏（有些国家为110伏）交流电，不能直接在计算机部件上使用。因此计算机和很多家电一样需要一个电源部分，负责将普通市电转换为计算机可以使用的电压，一般安装在计算机内部.";

    private float randomUpdateTime = 0;
    private float cpuValue;
    private float ramValue;

    bool haveFixed = false;

    private GameObject tarinList;
    private Button trainB1;
    private Button trainB2;
    private Button trainB3;
    private Button trainB4;
    private Button trainB5;

    
    private GameObject faultList;
    private Button faultB1;
    private Button faultB2;

    private Button faultB3;
    private Button faultB4;
    private Button faultB5;


    //$$$
    public Button[] faultButtons;
    public GameObject faultChoicePanel;
    public GameObject[] faultChoices;

    public GameObject[] powerFaultTips;
    public GameObject[] fanFaultTips;
    public GameObject[] ramFaultTips;
    public GameObject[] hardDiskFaultTips;
    public GameObject[] batteryFaultTips;

    private RectTransform faultTools;
    private GameObject faultSelectButtons;
    private IT_FaultToolList faultToolList;

    protected override void OnInit(object userData)
    {
        base.OnInit(userData);

        _trainPanel = this.transform.Find("trainPanel").gameObject;
        _learnPanel = this.transform.Find("learnPanel").gameObject;
        _faultPanel = this.transform.Find("faultPanel").gameObject;
        InItUiComponent();
        InitFaultTips();
    }

    protected override void OnOpen(object userData)
    {
        base.OnOpen(userData);
        _trainDoneTips.SetActive(false);
        _cpuButton.GetComponentInChildren<Text>().text = "CPU";
        _fanButton.GetComponentInChildren<Text>().text = "风冷";
        _powerButton.GetComponentInChildren<Text>().text = "电源";
        _ramButton.GetComponentInChildren<Text>().text = "内存";
        GameMain.Event.Subscribe(ReStart_IT_TrainStudyEvent.EventId, ReSetTrainUI);
        GameMain.Event.Subscribe(NextTrainStudyItemEvent.EventId, OnGetNextItem);
        GameMain.Event.Subscribe(IT_TrainStudyDoneEvent.EventId, OnIT_TrainStudyDone);
        GameMain.Event.Subscribe(IT_TrainStudyShowTargetInfoEvent.EventId, ChangeTargetMessage);
        GameMain.Event.Subscribe(IT_FaultNextEvent.EventId, OnGetIT_FaultNext);

        _learnPanel.SetActive(true);
        _trainPanel.SetActive(false);
        _learnButton.image.sprite = learnModelButtonImg[1];
        _trainButton.image.sprite = trainModelButtonImg[0];
        _faultButton.image.sprite = bugModelButtonImg[0];

        ChangeToLearn(true, 0.1f);

        tarinList.SetActive(false);
        //_currentType = IT_TrainModelType.learn;
        //GameMain.Event.Fire(this,IT_StartLearnTargetInfoEvent.Create());
    }

    protected override void OnUpdate(float elapseSeconds, float realElapseSeconds)
    {
        base.OnUpdate(elapseSeconds, realElapseSeconds);
        randomUpdateTime += elapseSeconds;
        if (randomUpdateTime >= 1)
        {
            if (haveFixed)
            {
                randomUpdateTime = 0;
                _cpuValueSlider.color = Color.green;
                _ramValueSlider.color = Color.green;
                cpuValue = Utility.Random.GetRandom(30, 40) * 0.01f;
                ramValue = Utility.Random.GetRandom(20, 30) * 0.01f;
                _cpuValueSlider.fillAmount = cpuValue;
                _cpuValueText.text = $"+{(int)(cpuValue * 100)}%";
                _ramValueSlider.fillAmount = ramValue;
                _ramValueText.text = $"+{(int)(ramValue * 100)}%";
            }
            else
            {
                randomUpdateTime = 0;
                _cpuValueSlider.color = Color.red;
                _ramValueSlider.color = new Color(1, 0.5f, 0);
                cpuValue = Utility.Random.GetRandom(86, 95) * 0.01f;
                ramValue = Utility.Random.GetRandom(63, 70) * 0.01f;
                _cpuValueSlider.fillAmount = cpuValue;
                _cpuValueText.text = $"+{(int)(cpuValue * 100)}%";
                _ramValueSlider.fillAmount = ramValue;
                _ramValueText.text = $"+{(int)(ramValue * 100)}%";
            }
        }
    }

    private void InItUiComponent()
    {
        _trainDoneTips = _trainPanel.transform.Find("DoneTips").gameObject;
        _trainDoneTips.SetActive(false);

        messagePanel = _learnPanel.transform.Find("messagePanel").gameObject;
        messagePanel.SetActive(false);
        nameText = messagePanel.transform.Find("nameText").GetComponent<Text>();
        messageText = messagePanel.transform.Find("messageText").GetComponent<Text>();

        _faultDoneTips = _faultPanel.transform.Find("DoneTips").gameObject;
        _faultDoneTips.SetActive(false);

        _faultPanel.SetActive(false);
        _reStartButton = _trainPanel.transform.Find("TrainButton/Verlist/reStartButton").GetComponent<Button>();
        _cpuButton = _trainPanel.transform.Find("TrainButton/Verlist/cpuButton").GetComponent<Button>();
        _ramButton = _trainPanel.transform.Find("TrainButton/Verlist/ramButton").GetComponent<Button>();
        _fanButton = _trainPanel.transform.Find("TrainButton/Verlist/fanButton").GetComponent<Button>();
        _powerButton = _trainPanel.transform.Find("TrainButton/Verlist/powerButton").GetComponent<Button>();

        _reStartButton.onClick.AddListener(() => { GameMain.Event.Fire(this, ReStart_IT_TrainStudyEvent.Create()); });

        _cpuButton.onClick.AddListener(() =>
        {
            if (!cpuDone)
            {
                GameMain.Event.Fire(this, StartTrainStudyItemEvent.Create(ITHardWaryType.cpu));
            }
        });
        _ramButton.onClick.AddListener(() =>
        {
            if (!ramDone)
            {
                GameMain.Event.Fire(this, StartTrainStudyItemEvent.Create(ITHardWaryType.ram));
            }
        });
        _fanButton.onClick.AddListener(() =>
        {
            if (!fanDone)
            {
                GameMain.Event.Fire(this, StartTrainStudyItemEvent.Create(ITHardWaryType.fan));
            }
        });

        _powerButton.onClick.AddListener(() =>
        {
            if (!powerDone)
            {
                GameMain.Event.Fire(this, StartTrainStudyItemEvent.Create(ITHardWaryType.power));
            }
        });

        //_overHotTips = _faultPanel.transform.Find("Show1/overhotTips").gameObject;

        _cpuValueSlider = _faultPanel.transform.Find("Show1/cpuValue/Fill").GetComponent<Image>();
        _cpuValueText = _faultPanel.transform.Find("Show1/cpuValue/valueText").GetComponent<Text>();
        _ramValueSlider = _faultPanel.transform.Find("Show1/ramValue/Fill").GetComponent<Image>();
        _ramValueText = _faultPanel.transform.Find("Show1/ramValue/valueText").GetComponent<Text>();

        _hardDiskTemperature = _faultPanel.transform.Find("Show1/hardDiskTemperature").GetComponent<Slider>();
        _hardDiskColor = _hardDiskTemperature.transform.Find("Fill Area/Fill").GetComponent<Image>();
        _mbTemperature = _faultPanel.transform.Find("Show1/mbTemperature").GetComponent<Slider>();
        _mbColor = _mbTemperature.transform.Find("Fill Area/Fill").GetComponent<Image>();
        _fanSpeed = _faultPanel.transform.Find("Show1/fanSpeed").GetComponent<Slider>();

        _reStarFaultButton = _faultPanel.transform.Find("FixButton/Verlist/reStartButton").GetComponent<Button>();
        _fanFaultButton = _faultPanel.transform.Find("FixButton/Verlist/fanButton").GetComponent<Button>();
        _cpuFaultButton = _faultPanel.transform.Find("FixButton/Verlist/cpuButton").GetComponent<Button>();
        _ramFaultButton = _faultPanel.transform.Find("FixButton/Verlist/ramButton").GetComponent<Button>();
        _powerFaultButton = _faultPanel.transform.Find("FixButton/Verlist/powerButton").GetComponent<Button>();
        _hardDiskFaultButton = _faultPanel.transform.Find("FixButton/Verlist/hardDiskButton").GetComponent<Button>();
        _batteryFaultButton = _faultPanel.transform.Find("FixButton/Verlist/batteryButton").GetComponent<Button>();

        _reStarFaultButton.onClick.AddListener(() => { });
        _fanFaultButton.onClick.AddListener(() =>
        {
            //fanDone = false;
            //GameMain.Event.Fire(this, StartTrainStudyItemEvent.Create(ITHardWaryType.fan));
            GameMain.Event.Fire(this, SelectFaultItemEvent.Create(IT_FaultType.fan));
        });
        _cpuFaultButton.onClick.AddListener(() =>
        {
            //GameMain.UI.OpenUIForm("Tips",new TipsData("排除故障错误！","排除故障错误！注意分析仪表数据"));
            GameMain.Event.Fire(this, SelectFaultItemEvent.Create(IT_FaultType.cpu));
        });
        _ramFaultButton.onClick.AddListener(() =>
        {
            //GameMain.UI.OpenUIForm("Tips",new TipsData("排除故障错误！","排除故障错误！注意分析仪表数据"));
            GameMain.Event.Fire(this, SelectFaultItemEvent.Create(IT_FaultType.ram));
            //Debug.Log("ram!!!");
        });
        _powerFaultButton.onClick.AddListener(() =>
        {
            //GameMain.UI.OpenUIForm("Tips",new TipsData("排除故障错误！","排除故障错误！注意分析仪表数据"));
            GameMain.Event.Fire(this, SelectFaultItemEvent.Create(IT_FaultType.power));
        });
        _hardDiskFaultButton.onClick.AddListener(() =>
        {
            //GameMain.UI.OpenUIForm("Tips",new TipsData("排除故障错误！","排除故障错误！注意分析仪表数据"));
            GameMain.Event.Fire(this, SelectFaultItemEvent.Create(IT_FaultType.hardDisk));
        });
        _batteryFaultButton.onClick.AddListener(() =>
        {
            //GameMain.UI.OpenUIForm("Tips",new TipsData("排除故障错误！","排除故障错误！注意分析仪表数据"));
            GameMain.Event.Fire(this, SelectFaultItemEvent.Create(IT_FaultType.battery));
        });

        _learnButton = this.transform.Find("Navi/B1").GetComponent<Button>();
        _learnButton.onClick.AddListener(() => { ChangeToLearn(true, 0.1f); });
        _trainButton = this.transform.Find("Navi/B2").GetComponent<Button>();
        _trainButton.onClick.AddListener(ChangeToTrain);
        _faultButton = this.transform.Find("Navi/B3").GetComponent<Button>();
        _faultButton.onClick.AddListener(() => { ChangeToFault(); });


        tarinList = this.transform.Find("Navi/trainlist").gameObject;
        trainB1 = this.transform.Find("Navi/trainlist/B1").GetComponent<Button>();
        trainB2 = this.transform.Find("Navi/trainlist/B2").GetComponent<Button>();
        trainB3 = this.transform.Find("Navi/trainlist/B3").GetComponent<Button>();
        trainB4 = this.transform.Find("Navi/trainlist/B4").GetComponent<Button>();
        trainB5 = this.transform.Find("Navi/trainlist/B5").GetComponent<Button>();

        trainB1.onClick.AddListener(() =>
        {
            GameMain.Event.Fire(this, IT_TrainAniEvent.Create(1));
            tarinList.SetActive(false);
        });

        trainB2.onClick.AddListener(() =>
        {
            GameMain.Event.Fire(this, IT_TrainAniEvent.Create(2));
            tarinList.SetActive(false);
        });
        trainB3.onClick.AddListener(() =>
        {
            GameMain.Event.Fire(this, IT_TrainAniEvent.Create(3));
            tarinList.SetActive(false);
        });
        trainB4.onClick.AddListener(() =>
        {
            GameMain.Event.Fire(this, IT_TrainAniEvent.Create(4));
            tarinList.SetActive(false);
        });
        trainB5.onClick.AddListener(() =>
        {
            GameMain.Event.Fire(this, IT_TrainAniEvent.Create(5));
            tarinList.SetActive(false);
        });

        tarinList.SetActive(false);

        faultList = this.transform.Find("Navi/faultlist").gameObject;
        faultB1 = this.transform.Find("Navi/faultlist/B1").GetComponent<Button>();
        faultB2 = this.transform.Find("Navi/faultlist/B2").GetComponent<Button>();

        faultB3 = this.transform.Find("Navi/faultlist/B3").GetComponent<Button>();
        faultB4 = this.transform.Find("Navi/faultlist/B4").GetComponent<Button>();
        faultB5 = this.transform.Find("Navi/faultlist/B5").GetComponent<Button>();


        faultB1.onClick.AddListener(() =>
        {
            foreach (var objs in faultChoices)
            {
                objs.SetActive(false);
            }

            faultChoicePanel.SetActive(false);
            GameMain.Event.Fire(this, FaultChoicesChangeEvent.Create(-1));
            GameMain.Event.Fire(this, IT_FaultStartEvent.Create(IT_FaultType.power));
            faultList.SetActive(false);
        });

        faultB2.onClick.AddListener(() =>
        {
            foreach (var objs in faultChoices)
            {
                objs.SetActive(false);
            }

            faultChoicePanel.SetActive(false);
            GameMain.Event.Fire(this, FaultChoicesChangeEvent.Create(-1));
            GameMain.Event.Fire(this, IT_FaultStartEvent.Create(IT_FaultType.fan));
            faultList.SetActive(false);
        });

        faultB3.onClick.AddListener(() =>
        {
            foreach (var objs in faultChoices)
            {
                objs.SetActive(false);
            }

            faultChoicePanel.SetActive(false);
            GameMain.Event.Fire(this, FaultChoicesChangeEvent.Create(-1));
            GameMain.Event.Fire(this, IT_FaultStartEvent.Create(IT_FaultType.ram));
            faultList.SetActive(false);
        });

        faultB4.onClick.AddListener(() =>
        {
            foreach (var objs in faultChoices)
            {
                objs.SetActive(false);
            }

            faultChoicePanel.SetActive(false);
            GameMain.Event.Fire(this, FaultChoicesChangeEvent.Create(-1));
            GameMain.Event.Fire(this, IT_FaultStartEvent.Create(IT_FaultType.hardDisk));
            faultList.SetActive(false);
        });

        faultB5.onClick.AddListener(() =>
        {
            foreach (var objs in faultChoices)
            {
                objs.SetActive(false);
            }

            faultChoicePanel.SetActive(false);
            GameMain.Event.Fire(this, FaultChoicesChangeEvent.Create(-1));
            GameMain.Event.Fire(this, IT_FaultStartEvent.Create(IT_FaultType.battery));
            faultList.SetActive(false);
        });

        //$$$------------------------
        faultChoicePanel = this.transform.Find($"faultChoicePanel").gameObject;
        faultChoices = new GameObject[8];
        for (int i = 0; i < 8; i++)
        {
            faultChoices[i] = this.transform.Find($"faultChoicePanel/BG/Quest_{i + 1}").gameObject;
            faultChoices[i].SetActive(false);
        }

        faultChoicePanel.SetActive(false);

        faultButtons = new Button[5];
        for (int i = 0; i < 5; i++)
        {
            faultButtons[i] = this.transform.Find($"Navi/faultlist/B{i + 6}").GetComponent<Button>();
        }

        faultButtons[0].onClick.AddListener(() => { faultChoicesClick(0); });
        faultButtons[1].onClick.AddListener(() => { faultChoicesClick(1); });
        faultButtons[2].onClick.AddListener(() => { faultChoicesClick(2); });
        faultButtons[3].onClick.AddListener(() => { faultChoicesClick(3); });
        faultButtons[4].onClick.AddListener(() => { faultChoicesClick(4); });

        faultChoicePanel.SetActive(false);
        //$$$------------------------

        faultList.SetActive(false);
    }

    //$$$------------------------
    private void faultChoicesClick(int index)
    {
        foreach (var obj in powerFaultTips)
        {
            obj.SetActive(false);
        }
        foreach (var obj in fanFaultTips)
        {
            obj.SetActive(false);
        }
        foreach (var obj in ramFaultTips)
        {
            obj.SetActive(false);
        }
        foreach (var obj in hardDiskFaultTips)
        {
            obj.SetActive(false);
        }
        foreach (var obj in batteryFaultTips)
        {
            obj.SetActive(false);
        }
        faultSelectButtons.SetActive(false);
        
        foreach (var objs in faultChoices)
        {
            objs.SetActive(false);
        }
        GameMain.Event.Fire(this, FaultChoicesChangeEvent.Create(index));
        faultChoices[index].SetActive(true);
        faultChoicePanel.SetActive(true);
        faultList.SetActive(false);
    }

    private void InitFaultTips()
    {
        fanFaultTips = new GameObject[7];
        for (int i = 0; i < fanFaultTips.Length; i++)
        {
            fanFaultTips[i] = _faultPanel.transform.Find($"Doc/BG/Step1_{i}").gameObject;
            fanFaultTips[i].SetActive(false);
        }

        powerFaultTips = new GameObject[6];
        for (int i = 0; i < powerFaultTips.Length; i++)
        {
            powerFaultTips[i] = _faultPanel.transform.Find($"Doc/BG/Step2_{i}").gameObject;
            powerFaultTips[i].SetActive(false);
        }

        ramFaultTips = new GameObject[6];
        for (int i = 0; i < ramFaultTips.Length; i++)
        {
            ramFaultTips[i] = _faultPanel.transform.Find($"Doc/BG/Step3_{i}").gameObject;
            ramFaultTips[i].SetActive(false);
        }

        hardDiskFaultTips = new GameObject[6];
        for (int i = 0; i < hardDiskFaultTips.Length; i++)
        {
            hardDiskFaultTips[i] = _faultPanel.transform.Find($"Doc/BG/Step4_{i}").gameObject;
            hardDiskFaultTips[i].SetActive(false);
        }

        batteryFaultTips = new GameObject[6];
        for (int i = 0; i < batteryFaultTips.Length; i++)
        {
            batteryFaultTips[i] = _faultPanel.transform.Find($"Doc/BG/Step5_{i}").gameObject;
            batteryFaultTips[i].SetActive(false);
        }

        faultTools = _faultPanel.transform.Find($"Tools").GetComponent<RectTransform>();
        faultTools.localPosition = new Vector3(1120, 0, 0);

        faultSelectButtons = _faultPanel.transform.Find($"FixButton").gameObject;
        faultSelectButtons.SetActive(false);

        faultToolList = faultTools.GetComponent<IT_FaultToolList>();
    }

    protected override void OnClose(bool isShutdown, object userData)
    {
        base.OnClose(isShutdown, userData);
        GameMain.Event.Unsubscribe(ReStart_IT_TrainStudyEvent.EventId, ReSetTrainUI);
        GameMain.Event.Unsubscribe(NextTrainStudyItemEvent.EventId, OnGetNextItem);
        GameMain.Event.Unsubscribe(IT_TrainStudyDoneEvent.EventId, OnIT_TrainStudyDone);
        GameMain.Event.Unsubscribe(IT_TrainStudyShowTargetInfoEvent.EventId, ChangeTargetMessage);
        GameMain.Event.Unsubscribe(IT_FaultNextEvent.EventId, OnGetIT_FaultNext);
    }

    private async void ChangeToLearn(bool force = false, float delayTime = 0.0f)
    {
        tarinList.SetActive(false);
        _faultDoneTips.SetActive(false);
        faultList.SetActive(false);
        if (_currentType == IT_TrainModelType.learn && !force)
            return;


        if (SceneManager.GetActiveScene().name != "TrainStudy")
            SceneManager.LoadScene("TrainStudy");


        await Task.Delay((int)(delayTime * 1000));
        GameMain.Event.Fire(this, IT_TrainStudyStateEvent.Create(false));
        GameMain.Event.Fire(this, IT_StartLearnTargetInfoEvent.Create());
        _currentType = IT_TrainModelType.learn;
        _learnButton.image.sprite = learnModelButtonImg[1];
        _trainButton.image.sprite = trainModelButtonImg[0];
        _faultButton.image.sprite = bugModelButtonImg[0];
        _trainPanel.SetActive(false);
        _learnPanel.SetActive(true);
        _faultPanel.SetActive(false);
        //$$$------------------------
        faultChoicePanel.SetActive(false);
    }

    private void ChangeToTrain()
    {
        faultList.SetActive(false);
        tarinList.SetActive(true);
        if (_currentType == IT_TrainModelType.train)
            return;
        _learnPanel.SetActive(false);
        _faultPanel.SetActive(false);
        _learnButton.image.sprite = learnModelButtonImg[0];
        _trainButton.image.sprite = trainModelButtonImg[1];
        _faultButton.image.sprite = bugModelButtonImg[0];
        _currentType = IT_TrainModelType.train;

        if (SceneManager.GetActiveScene().name != "TrainStudy1")
            SceneManager.LoadScene("TrainStudy1");
        //_trainPanel.SetActive(true);
        //$$$------------------------
        faultChoicePanel.SetActive(false);
    }


    private async void ChangeToFault(bool force = false)
    {
        tarinList.SetActive(false);
        faultList.SetActive(true);
        if (_currentType == IT_TrainModelType.fault && !force)
            return;
        GameMain.Event.Fire(this, IT_TrainStudyStateEvent.Create(false));
        GameMain.Event.Fire(this, IT_StartLearnTargetInfoEvent.Create(false));
        _learnButton.image.sprite = learnModelButtonImg[0];
        _trainButton.image.sprite = trainModelButtonImg[0];
        _faultButton.image.sprite = bugModelButtonImg[1];
        _faultPanel.SetActive(true);
        _trainPanel.SetActive(false);
        _learnPanel.SetActive(false);
        _currentType = IT_TrainModelType.fault;
        _faultPanel.transform.Find($"Doc").gameObject.SetActive(false);
        _faultPanel.transform.Find($"FixButton").gameObject.SetActive(false);
        _faultPanel.transform.Find($"Tools").GetComponent<RectTransform>().localPosition = new Vector3(1120, 0, 0);
        if (SceneManager.GetActiveScene().name != "TrainStudy1_2" || force)
            SceneManager.LoadScene("TrainStudy1_2");

        //ResetFaultPanel();

        //await Task.Delay((int)(1000));
        //GameMain.Event.Fire(this, IT_FaultStartEvent.Create(IT_FaultType.power));
        //$$$------------------------
        faultChoicePanel.SetActive(false);
    }

    private void ResetFaultPanel()
    {
        _faultDoneTips.SetActive(false);
        haveFixed = false;
        DOTween.Kill("_fanSpeed");
        DOTween.Kill("_mbTemperature");
        DOTween.Kill("_hardDiskTemperature");
        //_overHotTips.SetActive(true);
        _mbTemperature.value = 9;
        _mbTemperature.DOValue(8, 0.8f).SetLoops(-1, LoopType.Yoyo).SetId("_mbTemperature");
        _hardDiskTemperature.value = 9;
        _hardDiskTemperature.DOValue(8, 1.2f).SetLoops(-1, LoopType.Yoyo).SetId("_hardDiskTemperature");
        _fanSpeed.value = 0;
        _hardDiskColor.color = Color.red;
        _mbColor.color = Color.red;
    }

    private void FixFault(ITHardWaryType type)
    {
        switch (type)
        {
            case ITHardWaryType.cpu:

                break;
            case ITHardWaryType.fan:

                break;
            case ITHardWaryType.ram:

                break;
            case ITHardWaryType.power:

                break;
            case ITHardWaryType.none:
                break;
        }
    }

    private void ChangeTargetMessage(object sender, GameEventArgs e)
    {
        IT_TrainStudyShowTargetInfoEvent args = (IT_TrainStudyShowTargetInfoEvent)e;
        switch (args._Type)
        {
            case ITHardWaryType.cpu:
                nameText.text = "CPU";
                messageText.text = cpuMessage;
                if (!messagePanel.activeSelf)
                {
                    messagePanel.SetActive(true);
                }

                break;
            case ITHardWaryType.fan:
                nameText.text = "风冷";
                messageText.text = fanMessage;
                if (!messagePanel.activeSelf)
                {
                    messagePanel.SetActive(true);
                }

                break;
            case ITHardWaryType.ram:
                nameText.text = "内存";
                messageText.text = ramMessage;
                if (!messagePanel.activeSelf)
                {
                    messagePanel.SetActive(true);
                }

                break;
            case ITHardWaryType.power:
                nameText.text = "电源";
                messageText.text = powerMessage;
                if (!messagePanel.activeSelf)
                {
                    messagePanel.SetActive(true);
                }

                break;
            case ITHardWaryType.none:
                messagePanel.SetActive(false);
                break;
        }
    }

    private void OnGetNextItem(object sender, GameEventArgs e)
    {
        NextTrainStudyItemEvent args = (NextTrainStudyItemEvent)e;
        switch (args.ItHardWaryType)
        {
            case ITHardWaryType.cpu:
                cpuDone = true;
                _cpuButton.GetComponentInChildren<Text>().text = "CPU(已放置)";
                break;
            case ITHardWaryType.fan:
                if (_currentType == IT_TrainModelType.fault)
                {
                    fanDone = true;
                    _faultDoneTips.SetActive(true);
                    DOTween.Kill("_fanSpeed");
                    DOTween.Kill("_mbTemperature");
                    DOTween.Kill("_hardDiskTemperature");
                    haveFixed = true;
                    //_overHotTips.SetActive(false);
                    _mbTemperature.value = 4;
                    _mbTemperature.DOValue(3, 1.8f).SetLoops(-1, LoopType.Yoyo).SetId("_mbTemperature");
                    _hardDiskTemperature.value = 5;
                    _hardDiskTemperature.DOValue(4, 1.3f).SetLoops(-1, LoopType.Yoyo).SetId("_hardDiskTemperature");
                    _fanSpeed.DOValue(7, 1.0f).SetLoops(-1, LoopType.Yoyo).SetId("_fanSpeed");
                    _fanSpeed.value = 8;
                    _hardDiskColor.color = Color.green;
                    _mbColor.color = Color.green;
                }
                else
                {
                    fanDone = true;
                    _fanButton.GetComponentInChildren<Text>().text = "风冷(已放置)";
                }

                break;
            case ITHardWaryType.power:
                powerDone = true;
                _powerButton.GetComponentInChildren<Text>().text = "电源(已放置)";
                break;
            case ITHardWaryType.ram:
                ramDone = true;
                _ramButton.GetComponentInChildren<Text>().text = "内存(已放置)";
                break;
        }
    }

    private void ReSetTrainUI(object sender, GameEventArgs e)
    {
        _trainDoneTips.SetActive(false);
        _cpuButton.GetComponentInChildren<Text>().text = "CPU";
        _fanButton.GetComponentInChildren<Text>().text = "风冷";
        _powerButton.GetComponentInChildren<Text>().text = "电源";
        _ramButton.GetComponentInChildren<Text>().text = "内存";
        cpuDone = false;
        fanDone = false;
        ramDone = false;
        powerDone = false;
    }

    private void OnIT_TrainStudyDone(object sender, GameEventArgs e)
    {
        //Debug.Log(11111111111);
        _faultDoneTips.SetActive(true);
        ChangeToFault(true);
        //GameMain.UI.OpenUIForm("Tips", "Pop");
    }

    private void OnGetIT_FaultNext(object sender, GameEventArgs e)
    {
        IT_FaultNextEvent args = (IT_FaultNextEvent)e;
        _faultPanel.transform.Find($"Doc").gameObject.SetActive(true);
        switch (args.FaultType)
        {
            case IT_FaultType.fan:
                for (int i = 0; i < fanFaultTips.Length; i++)
                {
                    fanFaultTips[i].SetActive(false);
                }

                fanFaultTips[args.stepIndex].SetActive(true);
                if (args.stepIndex == 0)
                {
                    for (int i = 0; i < powerFaultTips.Length; i++)
                    {
                        powerFaultTips[i].SetActive(false);
                    }

                    for (int i = 0; i < ramFaultTips.Length; i++)
                    {
                        ramFaultTips[i].SetActive(false);
                    }

                    foreach (var t in hardDiskFaultTips)
                    {
                        t.SetActive(false);
                    }

                    foreach (var t in batteryFaultTips)
                    {
                        t.SetActive(false);
                    }

                    faultSelectButtons.SetActive(true);
                    faultTools.localPosition = new Vector3(1120, 0, 0);
                    faultToolList.ReSetToolList(1);
                }
                else
                {
                    if (args.stepIndex == 4)
                    {
                        faultToolList.ShowChassisCover();
                    }

                    faultSelectButtons.SetActive(false);
                    faultTools.localPosition = new Vector3(920, 0, 0);
                }

                break;
            case IT_FaultType.power:
                for (int i = 0; i < powerFaultTips.Length; i++)
                {
                    powerFaultTips[i].SetActive(false);
                }

                powerFaultTips[args.stepIndex].SetActive(true);

                if (args.stepIndex == 0)
                {
                    for (int i = 0; i < fanFaultTips.Length; i++)
                    {
                        fanFaultTips[i].SetActive(false);
                    }

                    for (int i = 0; i < ramFaultTips.Length; i++)
                    {
                        ramFaultTips[i].SetActive(false);
                    }

                    foreach (var t in hardDiskFaultTips)
                    {
                        t.SetActive(false);
                    }

                    foreach (var t in batteryFaultTips)
                    {
                        t.SetActive(false);
                    }

                    faultSelectButtons.SetActive(true);
                    faultTools.localPosition = new Vector3(1120, 0, 0);
                    faultToolList.ReSetToolList(0);
                }
                else
                {
                    faultSelectButtons.SetActive(false);
                    faultTools.localPosition = new Vector3(920, 0, 0);
                }

                break;
            case IT_FaultType.ram:
                foreach (var t in ramFaultTips)
                {
                    t.SetActive(false);
                }

                ramFaultTips[args.stepIndex].SetActive(true);
                if (args.stepIndex == 0)
                {
                    foreach (var t in fanFaultTips)
                    {
                        t.SetActive(false);
                    }

                    foreach (var t in powerFaultTips)
                    {
                        t.SetActive(false);
                    }

                    foreach (var t in hardDiskFaultTips)
                    {
                        t.SetActive(false);
                    }

                    foreach (var t in batteryFaultTips)
                    {
                        t.SetActive(false);
                    }

                    faultSelectButtons.SetActive(true);
                    faultTools.localPosition = new Vector3(1120, 0, 0);
                    faultToolList.ReSetToolList(2);
                }
                else
                {
                    if (args.stepIndex == 4)
                    {
                        faultToolList.ShowChassisCover();
                    }

                    faultSelectButtons.SetActive(false);
                    faultTools.localPosition = new Vector3(920, 0, 0);
                }

                break;
            case IT_FaultType.hardDisk:
                foreach (var t in hardDiskFaultTips)
                {
                    t.SetActive(false);
                }

                hardDiskFaultTips[args.stepIndex].SetActive(true);
                if (args.stepIndex == 0)
                {
                    foreach (var t in fanFaultTips)
                    {
                        t.SetActive(false);
                    }

                    foreach (var t in powerFaultTips)
                    {
                        t.SetActive(false);
                    }

                    foreach (var t in ramFaultTips)
                    {
                        t.SetActive(false);
                    }

                    foreach (var t in batteryFaultTips)
                    {
                        t.SetActive(false);
                    }

                    faultSelectButtons.SetActive(true);
                    faultTools.localPosition = new Vector3(1120, 0, 0);
                    faultToolList.ReSetToolList(3);
                }
                else
                {
                    if (args.stepIndex == 4)
                    {
                        faultToolList.ShowChassisCover();
                    }

                    faultSelectButtons.SetActive(false);
                    faultTools.localPosition = new Vector3(920, 0, 0);
                }

                break;
            case IT_FaultType.battery:
                foreach (var t in batteryFaultTips)
                {
                    t.SetActive(false);
                }

                batteryFaultTips[args.stepIndex].SetActive(true);
                if (args.stepIndex == 0)
                {
                    foreach (var t in fanFaultTips)
                    {
                        t.SetActive(false);
                    }

                    foreach (var t in powerFaultTips)
                    {
                        t.SetActive(false);
                    }

                    foreach (var t in ramFaultTips)
                    {
                        t.SetActive(false);
                    }

                    foreach (var t in hardDiskFaultTips)
                    {
                        t.SetActive(false);
                    }

                    faultSelectButtons.SetActive(true);
                    faultTools.localPosition = new Vector3(1120, 0, 0);
                    faultToolList.ReSetToolList(4);
                }
                else
                {
                    if (args.stepIndex == 4)
                    {
                        faultToolList.ShowChassisCover();
                    }

                    faultSelectButtons.SetActive(false);
                    faultTools.localPosition = new Vector3(920, 0, 0);
                }

                break;
        }
    }
}