ChunilENG/Assets/WorkSpace/Review/DataManager.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using static MQTT;
using WI;
using System.Text.RegularExpressions;
using UnityEngine;
using System.Linq;
using Newtonsoft.Json;

namespace CHN
{
    public class DataManager : MonoBehaviour, ISingle
    {
        private Machine[] machines;

        private List<ThermostatData> thermostatDatas = new();
        private Thermostat currentThermostat;
        public Action<ThermostatData> onSetThermostatData;

        public Action<Machine, SimpleField> onCompleteInfo;
        public Action<Machine, SimpleField> onSimpleInfo;
        public Action<List<SimpleField>> onKPIInfo;

        private Dictionary<string, UsageMQTTData> mqttDataTable = new();
        private Dictionary<string, UsageKPIData> kpiDataTable = new();

        public SDictionary<string, SimpleField> includeFields = new();
        public Dictionary<string, SimpleField> simpleFields = new();
        private HashSet<string> samples = new();

        public KPIData kpiData;
        private string dataOrder;
        public override void AfterAwake()
        {
            dataOrder = Resources.Load<TextAsset>("DataOrder").text;
            machines = FindObjectsByType<Machine>(FindObjectsSortMode.None);

            foreach (var machine in machines)
            {
                if (string.IsNullOrEmpty(machine.code))
                    continue;

                if (mqttDataTable.ContainsKey(GapRemove(machine.code)))
                    continue;

                mqttDataTable.Add(GapRemove(machine.code), new());

                if (kpiDataTable.ContainsKey(GapRemove(machine.code)))
                    continue;

                kpiDataTable.Add(GapRemove(machine.code), new());
            }
            var fileds = typeof(UsageMQTTData).GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
            var typeFields = typeof(UsageKPIData).GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);

            for (int i = 0; i < 4; i++)
            {
                samples.Add(fileds[i].Name);
            }

            for (int i = 0; i < 3; i++)
            {
                samples.Add(typeFields[i].Name);
            }
        }

        public void SetKPIData(MachineKPIData machineKPIData)
        {
            foreach (var rows in machineKPIData.data.rows)
            {
                var id = rows.workcd;
                var name = GapRemove(id);

                if (kpiDataTable.ContainsKey(name))
                {
                    kpiDataTable[name] = SetUsageKPIData(rows);
                }
            }
            SetMachineData();
        }

        public void MachineMatching(List<CompleteInfo> machineInfos)
        {
            foreach (CompleteInfo info in machineInfos)
            {
                var id = info.workcd;
                var name = GapRemove(id);
                if (mqttDataTable.ContainsKey(name))
                {
                    mqttDataTable[name] = SetUsageMQTTData(info);
                }
            }
            SetMachineData();
        }

        private void SetMachineData()
        {
            foreach (var machine in machines)
            {
                if (string.IsNullOrEmpty(machine.code))
                    return;

                var machineName = GapRemove(machine.code);

                if (!includeFields.ContainsKey(machineName))
                {
                    var simpleData = new SimpleField();
                    simpleData.machineName = machineName;
                    simpleData.machineInfo = new UsageMQTTData();
                    simpleData.kpiDataInfo = new UsageKPIData();
                    simpleData.simpleField = samples;
                    includeFields.Add(machineName, simpleData);
                }

                if (mqttDataTable.Count != 0)
                {
                    includeFields[machineName].machineInfo = mqttDataTable[machineName];
                }

                if (kpiDataTable.Count != 0)
                {
                    includeFields[machineName].kpiDataInfo = kpiDataTable[machineName];
                }
            }

            var newIncludeFields = SortListByWorkcd(includeFields.Values.ToList());

            onKPIInfo.Invoke(newIncludeFields);
        }

        public void GetSimpleCompleteData(Machine machine)
        {
            if (string.IsNullOrEmpty(machine.code))
                return;
            var machineName = GapRemove(machine.code);
            if (includeFields.ContainsKey(machineName))
            {
                includeFields[machineName].machineInfo = mqttDataTable[machineName];
                includeFields[machineName].kpiDataInfo = kpiDataTable[machineName];
            }
            else
            {
                var simpleTest = new SimpleField();
                simpleTest.machineName = machineName;
                simpleTest.machineInfo = mqttDataTable[machineName];
                simpleTest.kpiDataInfo = kpiDataTable[machineName];
                simpleTest.simpleField = samples;
                includeFields.Add(machineName, simpleTest);
            }

            onSimpleInfo?.Invoke(machine, includeFields[machineName]);
        }

        public void SimpleFiledChange(Machine machine, HashSet<string> fields)
        {
            if (string.IsNullOrEmpty(machine.code))
                return;
            var machineName = GapRemove(machine.code);
            var simpleField = includeFields[machineName];
            simpleField.simpleField = fields;
            includeFields[machineName] = simpleField;
        }

        public void GetCompleteInfo(Machine machine)
        {
            if (string.IsNullOrEmpty(machine.code))
                return;
            var machineName = GapRemove(machine.code);
            var simpleField = includeFields[machineName];
            onCompleteInfo?.Invoke(machine, simpleField);
        }

        string GapRemove(string name)
        {
            return Regex.Replace(name, @"\s", "");
        }


        private UsageKPIData SetUsageKPIData(KPIData kpiData)
        {
            var usageKPIData = new UsageKPIData();

            usageKPIData.eorate = kpiData.eorate;
            usageKPIData.porate = kpiData.porate;
            usageKPIData.goodqtyrate = kpiData.goodqtyrate;

            return usageKPIData;
        }

        private UsageMQTTData SetUsageMQTTData(CompleteInfo completeInfos)
        {
            var usageMQTTData = new UsageMQTTData();

            usageMQTTData.wordno = completeInfos.wordno;
            usageMQTTData.workdt = completeInfos.workdt;
            usageMQTTData.daynight = completeInfos.daynight;
            usageMQTTData.workcd = completeInfos.workcd;
            usageMQTTData.worknm = completeInfos.worknm;
            usageMQTTData.workseq = completeInfos.workseq;
            usageMQTTData.statusnm = completeInfos.statusnm;
            usageMQTTData.itemcd = completeInfos.itemcd;
            usageMQTTData.itemdesc = completeInfos.itemdesc;
            usageMQTTData.pjtcd = completeInfos.pjtcd;
            usageMQTTData.matcd = completeInfos.matcd;
            usageMQTTData.cycletime = completeInfos.cycletime;
            usageMQTTData.cavity = completeInfos.cavity;
            usageMQTTData.planqty = completeInfos.planqty;
            usageMQTTData.goalqty = completeInfos.goalqty;
            usageMQTTData.workqty = completeInfos.workqty;
            usageMQTTData.goodqty = completeInfos.goodqty;
            usageMQTTData.badqty = completeInfos.badqty;
            usageMQTTData.badrate = completeInfos.badrate;
            usageMQTTData.efficiency = completeInfos.efficiency;
            usageMQTTData.progressrate = completeInfos.progressrate;
            usageMQTTData.sttm = completeInfos.sttm;
            usageMQTTData.totm = completeInfos.totm;
            usageMQTTData.moldcd = completeInfos.moldcd;
            usageMQTTData.moldseq = completeInfos.moldseq;

            return usageMQTTData;
        }

        public List<SimpleField> SortListByWorkcd(List<SimpleField> target)
        {
            List<string> workcdOrder = JsonConvert.DeserializeObject<List<string>>(dataOrder);

            Dictionary<string, int> orderMap = workcdOrder
                .Select((workcd, index) => new { workcd, index })
                .ToDictionary(x => x.workcd, x => x.index);

            return target
                .OrderBy(field => orderMap[field.machineName])
                .ToList();
        }
        public void SetThermostatDataList(List<ThermostatData> thermostatDatas)
        {
            this.thermostatDatas = thermostatDatas;
            UpdateShowThermostatData();
        }
        public void SetSelectedThermostatData(Thermostat thermostat)
        {
            currentThermostat = thermostat;
            UpdateShowThermostatData();
        }
        public void UpdateShowThermostatData()
        {
            if (currentThermostat == null || currentThermostat.machineCode == null)
                return;

            onSetThermostatData(thermostatDatas.Find(x => x.workcd == currentThermostat.machineCode));
        }
    }
    [Serializable]
    public class SimpleField
    {
        public string machineName;
        public UsageKPIData kpiDataInfo;
        public UsageMQTTData machineInfo;
        public HashSet<string> simpleField;
    }

    [Serializable]
    public class UsageKPIData
    {
        public string eorate;
        public string porate;
        public string goodqtyrate;
    }

    [Serializable]
    public class UsageMQTTData
    {
        public string wordno;
        public string workdt;
        public string daynight;
        public string workcd;
        public string worknm;
        public string workseq;
        public string statusnm;
        public string itemcd;
        public string itemdesc;
        public string pjtcd;
        public string matcd;
        public string cycletime;
        public string cavity;
        public string planqty;
        public string goalqty;
        public string workqty;
        public string goodqty;
        public string badqty;
        public string badrate;
        public string efficiency;
        public string progressrate;
        public string sttm;
        public string totm;
        public string moldcd;
        public string moldseq;
    }

}