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

namespace CHN
{
    public class DataManager : MonoBehaviour, ISingle
    {
        public Action<Machine, SimpleField> onCompleteInfo;
        public Action<Machine, SimpleField> onSimpleInfo;
        private Dictionary<string, CompleteInfo> machineTable = new();
        private Dictionary<string, SimpleField> includeFields = new();
        private HashSet<string> samples = new();
        private List<SimpleField> simpleField;
        private string simplePath;
        public override void AfterAwake()
        {
            var machines = FindObjectsOfType<Machine>();
            foreach (var machine in machines)
            {
                if (string.IsNullOrEmpty(machine.code))
                    continue;

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

                machineTable.Add(GapRemove(machine.code), new());
            }
            var fileds = typeof(CompleteInfo).GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
            //simpleField= JsonConvert.DeserializeObject<List<SimpleField>>(simplePath);
            for (int i = 0; i < 6; i++)
            {
                samples.Add(fileds[i].Name);
            }
        }

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

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

            //foreach(var simple in simpleField)
            //{
            //    var machineName = GapRemove(machine.name);
            //    if (simple.machineName.Equals(machineName))
            //    {
            //        simple.machineInfo = machineTable[machineName];
            //        onSimpleInfo?.Invoke(simple);
            //        break;
            //    }
            //}
            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", "");
        }
    }
    public class SimpleField
    {
        public string machineName;
        public CompleteInfo machineInfo;
        public HashSet<string> simpleField;
    }
}