ChunilENG/Assets/WorkSpace/Personal/JYM/CompleteTimeAlarmManager.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using UnityEngine;
using static MQTT;
using WI;
using System.Text;
using System.Linq;

namespace CHN
{
    [Serializable]
    public class Data
    {
        public List<CompleteTimeAlarmData> completeTimeAlarmDatas = new List<CompleteTimeAlarmData>();
    }

    [Serializable]
    public class CompleteTimeAlarmData
    {
        public CompleteInfo completeInfo;
        public bool isCheck;
    }
    public class CompleteTimeAlarmManager : MonoBehaviour, ISingle
    {
        public static string filePath = "./CompleteTimeAlarmInfo.json";

        public List<Machine> machines = new List<Machine>();
        public  List<CompleteTimeAlarmData> currentData = new List<CompleteTimeAlarmData>();

        public static Dictionary<string, CompleteTimeAlarmData> saveData = new Dictionary<string, CompleteTimeAlarmData>();

        public Action onNotloadData;
        public Action<List<CompleteTimeAlarmData>> onUnloadData;
        public Action<List<CompleteTimeAlarmData>> onLoadData;

        [RuntimeInitializeOnLoadMethod]
        static void RunOnStart()
        {
            Application.quitting += SaveCompleteTimeData;
        }
        public override void AfterAwake()
        {
            LoadCompleteTimeData();
        }
        public override void AfterStart()
        {
            var building = FindSingle<Building>();
            machines = building.floors.SelectMany(f => f.machines).ToList();
        }
        public void SetCurrentData(List<CompleteInfo> completeInfos)
        {
            currentData.Clear();
            foreach (var completeInfo in completeInfos)
            {
                CompleteTimeAlarmData completeTimeAlarmData = new CompleteTimeAlarmData();
                completeTimeAlarmData.completeInfo = completeInfo;

                completeTimeAlarmData.isCheck = false;

                currentData.Add(completeTimeAlarmData);
            }

            if (saveData.Count <= 0)
            {
                onUnloadData?.Invoke(currentData);
               
                foreach(var data in currentData)
                {
                    var worknm = data.completeInfo.worknm;
                    saveData.Add(worknm, data);
                }
            }
            else
            {
                CompleteTimeAlarmDataComparison();
            }
        }
        private void CompleteTimeAlarmDataComparison()
        {
            foreach(var data in currentData)
            {
                var currentWorknm = data.completeInfo.worknm;

                if (!saveData.ContainsKey(currentWorknm))
                {
                    saveData.Add(currentWorknm, data);
                }
                else
                {
                    var preInfo = saveData[currentWorknm].completeInfo;
                    var curInfo = data.completeInfo;

                    if (!preInfo.ptotm.Equals(curInfo.ptotm) || !preInfo.statusnm.Equals(curInfo.statusnm))
                    {
                        preInfo.ptotm = curInfo.ptotm;
                        preInfo.statusnm = curInfo.statusnm;
                        saveData[currentWorknm].isCheck = false;
                    }
                }
            }

            onLoadData?.Invoke(saveData.Values.ToList());
        }

        public void CheckCompleteTimeAlarm(CompleteInfo completeInfo, bool isCheck)
        {
            var worknm = completeInfo.worknm;
            saveData[worknm].isCheck = isCheck;
        }

        public void LoadCompleteTimeData()
        {
#if UNITY_EDITOR
            filePath = "../ChunilENG/CompleteTimeAlarmInfo.json";
#else
            filePath = "../ChunilENG_Build/CompleteTimeAlarmInfo.json";
#endif

            saveData.Clear();

            if (File.Exists(filePath))
            {
                var json = File.ReadAllText(filePath);
                var data = JsonUtility.FromJson<Data>(json);

                if (data != null)
                {
                    foreach(var d in data.completeTimeAlarmDatas)
                    {
                        saveData.Add(d.completeInfo.worknm, d);
                    }
                }
            }
        }

        public static void SaveCompleteTimeData()
        {
            Data data = new Data();

            if (!File.Exists(filePath))
            {
                using (var fs = File.Create(filePath))
                {
                    foreach (var saveData in saveData.Values)
                    {
                        data.completeTimeAlarmDatas.Add(saveData);
                    }

                    var json = JsonUtility.ToJson(data, true);
                    var bytes = Encoding.UTF8.GetBytes(json);
                    fs.Write(bytes, 0, bytes.Length);
                    fs.Flush();
                }
            }
            else
            {
                File.WriteAllText(filePath, "");

                foreach (var saveData in saveData.Values)
                {
                    data.completeTimeAlarmDatas.Add(saveData);
                }
                var json = JsonUtility.ToJson(data, true);

                File.WriteAllText(filePath, json);
            }
        }
        public void MachineCorrespondingToAlarm(string machineCode)
        {
            foreach(var machine in machines)
            {
                if(machine.code == machineCode)
                {
                    SetTargetPosToMachine(machine);
                    ActivateMachinesHighlight(machine);
                }
            }
        }
        public void ResetMachinesHighLight(string dashboardKey)
        {
            ResetAllMachinesHighLight();
        }

        private void ResetAllMachinesHighLight()
        {
            foreach (var machine in machines)
            {
                machine.DeactivateTranslucent();
                machine.StopFlash();
            }
        }

        private void ActivateMachinesHighlight(Machine alarmMachine)
        {
            ResetAllMachinesHighLight();

            foreach (Machine machine in machines)
            {
                if (alarmMachine != machine)
                {
                    machine.ActivateTranslucent();
                }
                else
                {
                    machine.StartFlash();
                }
            }
        }
        private void SetTargetPosToMachine(Machine machine)
        {
            OrbitalController controller = FindSingle<OrbitalController>();
            if (controller.viewMode != ViewMode.PerspectiveView)
            {
                controller.SetViewMode(ViewMode.PerspectiveView);
            }

            var building = FindSingle<Building>();
            int changeFloor = building.floors[0].floorIndex;

            int libraryMachineFloor = machine.GetMachineFloorIndex();
            if (libraryMachineFloor > changeFloor)
            {
                changeFloor = libraryMachineFloor;
            }

            var centerPos = machine.centerPos;

            var slider = FindSingle<Canvas_Right>().panel_floorcontrol;
            slider.ChangeValueFromOutside(changeFloor);

            controller.option.currentDistance = 20f;
            controller.SetTargetPos(centerPos);
        }
    }
}