EnglewoodLAB/Assets/Scripts/UI/SettingPanel/Panel_ProtocolSetting.cs

using SFB;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using UnityEngine;

namespace EnglewoodLAB.UI
{
    public class Panel_ProtocolSetting : SettingPanel, ISingle, IOptionable
    {
        [OptionSection]
        string defaultInfo;
        [OptionKey]
        string machineInfoPath = "./MachineStandardInfo.csv";

        public UI_InputOrFind UI_StandardInfoFile;
        public List<StandardInfo> standardInfos = new();
        public string[] machineFilters;
        public Action<string[]> onUpdateMachineFilters;
        public Action<List<StandardInfo>,string[]> onUpdateMachine;

        public UI_ProtocolSetting mqttData;
        public UI_ProtocolSetting httpData;

        private HTTPRequester httpManager;
        private MQTT mqttManager;

        public void InitOptionSetting()
        {
            httpManager = new HTTPRequester();
            mqttManager = FindFirstObjectByType<MQTT>();

            var allSettings_MQTT = FindObjectsByType<UI_ProtocolSetting>(FindObjectsInactive.Include, FindObjectsSortMode.None);
            mqttData = allSettings_MQTT.FirstOrDefault(x => x.name == "MQTTData");
            mqttData.InitInputFields(mqttManager);

            var allSettings_HTTP = FindObjectsByType<UI_ProtocolSetting>(FindObjectsInactive.Include, FindObjectsSortMode.None);
            httpData = allSettings_HTTP.FirstOrDefault(x => x.name == "HTTPData");
            httpData.InitInputFields(httpManager);

            var allSettings_UI = FindObjectsByType<UI_InputOrFind>(FindObjectsInactive.Include, FindObjectsSortMode.None);
            UI_StandardInfoFile = allSettings_UI.FirstOrDefault(x => x.name == "UI_StandardInfoFile");
            UI_StandardInfoFile.InitInfoFile(this);
            UI_StandardInfoFile.onClickFind += FindStandardInfo;
        }
        public void Update()
        {
            mqttData.ProtocolSuccessCheck(mqttManager);
            httpData.ProtocolSuccessCheck(httpManager);
        }

        public void Start()
        {
            ReadStandardInfo(new string[] { machineInfoPath });
            //FindSingle<Canvas_Popup>().panel_library.UpdateFileterList()
        }

        private void FindStandardInfo()
        {
            StandaloneFileBrowser.OpenFilePanelAsync("Open File", "", "csv", false, ReadStandardInfo);
        }

        string[] ReadRawFile(string path, char separator)
        {
            FileInfo fileInfo = new FileInfo(path);
            using (var fs = fileInfo.OpenRead())
            {
                var length = fs.Length;
                var buffer = new byte[length];
                fs.Read(buffer, 0, buffer.Length);
                string str = System.Text.Encoding.Default.GetString(buffer);
                return str.Split(separator);
            }
        }


        void ReadStandardInfo(string[] file)
        {
            var path = file[0];
            var rawData = ReadRawFile(path, '\n');

            UI_StandardInfoFile.SetPathText(path);
            UI_StandardInfoFile.SetErrorMessageText("Connected");

            standardInfos.Clear();
            bool warningChecker = false;
            HashSet<string> filterSet = new();
            for (int i = 1; i < rawData.Length - 1; ++i)
            {
                var r = rawData[i];
                var data = r.Split(',');
                if (data.Length < 2)
                {
                    //Debug.LogWarning("Error Data!");
                    UI_StandardInfoFile.SetErrorMessageText("UnConnected");
                    UI_StandardInfoFile.SetState(UI_InputOrFind.State.Error);
                    return;
                }
                var code = data[0];
                var name = data[1];
                if (code == "")
                {
                    //Debug.LogWarning("Code is Empty!");
                    UI_StandardInfoFile.SetErrorMessageText("UnConnected");
                    warningChecker = true;
                    break;
                }

                if (name == "")
                {
                    //Debug.LogWarning("Name is Empty!");
                    UI_StandardInfoFile.SetErrorMessageText("UnConnected");
                    warningChecker = true;
                    break;
                }

                data = data[2..];

                int prevLength = data.Length;
                data = data.Distinct().Where(d => d != "" && d != "\r").ToArray();
                for(int a = 0; a < data.Length; ++a)
                {
                    data[a] = data[a].Replace('\r',' ');
                }

                var standardInfo = new StandardInfo() { code = code, name = name, filterInfo = data };


                foreach (var f in standardInfo.filterInfo)
                {
                    if (f != "")
                        filterSet.Add(f);
                }

                standardInfos.Add(standardInfo);
            }
            if (warningChecker)
            {
                UI_StandardInfoFile.SetState(UI_InputOrFind.State.Warning);
                return;
            }

            machineFilters = filterSet.ToArray();
            UI_StandardInfoFile.SetState(UI_InputOrFind.State.Good);
            onUpdateMachine?.Invoke(standardInfos, machineFilters);
            //onUpdateMachineFilters?.Invoke(machineFilters);
        }

        public override void Reset()
        {
            mqttData.ResetInputFields(mqttManager);
            mqttManager.MQTTConnect();

            httpData.ResetInputFields(httpManager);
            httpManager.HTTPConnect();

            UI_StandardInfoFile.ResetInputOrFind(this);
            ReadStandardInfo(new string[] { machineInfoPath });
        }

        public override void Accept()
        {
            mqttData.AcceptInputFields(mqttManager);
            mqttManager.MQTTConnect();

            httpData.AcceptInputFields(httpManager);
            httpManager.HTTPConnect();

            UI_StandardInfoFile.AcceptInputOrFind(this);
            ReadStandardInfo(new string[] { machineInfoPath });
        }
        public override void Open()
        {
            base.Open();
        }
        public override void Close()
        {
            mqttData.UnAcceptInputFields(mqttManager);
            httpData.UnAcceptInputFields(httpManager);

            base.Close();
        }
    }
}