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;
        public Action<Machine> onActiveHighLighter;

        [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;

                    if (saveData.ContainsKey(worknm))
                        return;

                    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 (AlarmInfoCompare(preInfo, curInfo))
                    {
                        saveData[currentWorknm].completeInfo = curInfo;
                        saveData[currentWorknm].isCheck = false;
                    }
                }
            }

            onLoadData?.Invoke(saveData.Values.ToList());
        }
        private bool AlarmInfoCompare(CompleteInfo preInfo, CompleteInfo curInfo)
        {
            if (!preInfo.progressrate.Equals(curInfo.progressrate))
            {
                return true;
            }
            else if (!preInfo.ptotm.Equals(curInfo.ptotm))
            {
                return true;
            }
            else if (!preInfo.statusnm.Equals(curInfo.statusnm))
            {
                return true;
            }
            return false;
        }

        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)
                {
                    onActiveHighLighter?.Invoke(machine);
                }
            }
        }
    }
}