using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Xml;
using UnityEngine;
using UnityEngine.SceneManagement;

namespace OctoCore.Save
{
    /// <summary>
    /// Save system module for managing persistent game data.
    /// Handles saving and loading of boolean, integer, float, string, and vector data to XML files.
    /// </summary>
    [System.Serializable]
    public class OctoSave : IOctoModule
    {
        public class Data
        {
            [HideInInspector] public string Id;
        }
    
        [System.Serializable]
        public class DataBool : Data
        {
            [OctoReadOnly] public global::OctoCore.Save.Data.OctoDataBool Data;
            public bool Value;
            public Action<bool> OnValueChanged;
    
            public void Set(bool value)
            {
                bool valueChanged = Value != value;
                Value = value;
    
                if (valueChanged)
                    OnValueChanged?.Invoke(Value);
            }
    
            public void Set(OctoVirtual.OctoVirtualBool virtualBool)
            {
                if (virtualBool != null)
                    Set(virtualBool.Value);
                else if (OctoCore.Instance.Development.Log)
                    Debug.Log($"OctoVirtualBool is null");
            }
        }
    
        [System.Serializable]
        public class DataInt : Data
        {
            [OctoReadOnly] public global::OctoCore.Save.Data.OctoDataInt Data;
            public int Value;
            public Action<int> OnValueChanged;
    
            public void Set(int value)
            {
                bool valueChanged = Value != value;
                Value = value;
    
                if (valueChanged)
                    OnValueChanged?.Invoke(Value);
            }
    
            public void Set(OctoVirtual.OctoVirtualInt virtualInt)
            {
                if (virtualInt != null)
                    Set(virtualInt.Value);
                else if (OctoCore.Instance.Development.Log)
                    Debug.Log($"OctoVirtualInt is null");
            }
        }
    
        [System.Serializable]
        public class DataFloat : Data
        {
            [OctoReadOnly] public global::OctoCore.Save.Data.OctoDataFloat Data;
            public float Value;
            public Action<float> OnValueChanged;
    
            public void Set(float value)
            {
                bool valueChanged = Value != value;
                Value = value;
    
                if (valueChanged)
                    OnValueChanged?.Invoke(Value);
            }
    
            public void Set(OctoVirtual.OctoVirtualFloat virtualFloat)
            {
                if (virtualFloat != null)
                    Set(virtualFloat.Value);
                else if (OctoCore.Instance.Development.Log)
                    Debug.Log($"OctoVirtualFloat is null");
            }
        }
    
        [System.Serializable]
        public class DataString : Data
        {
            [OctoReadOnly] public global::OctoCore.Save.Data.OctoDataString Data;
            public string Value;
            public Action<string> OnValueChanged;
    
            public void Set(string value)
            {
                bool valueChanged = Value != value;
                Value = value;
    
                if (valueChanged)
                    OnValueChanged?.Invoke(Value);
            }
    
            public void Set(OctoVirtual.OctoVirtualString virtualString)
            {
                if (virtualString != null)
                    Set(virtualString.Value);
                else if (OctoCore.Instance.Development.Log)
                    Debug.Log($"OctoVirtualString is null");
            }
        }
    
        [System.Serializable]
        public class DataVector : Data
        {
            [OctoReadOnly] public global::OctoCore.Save.Data.OctoDataVector Data;
            public Vector4 Value;
            public Action<Vector4> OnValueChanged;
    
            public void Set(Vector4 value)
            {
                bool valueChanged = Value != value;
                Value = value;
    
                if (valueChanged)
                    OnValueChanged?.Invoke(Value);
            }
    
            public void Set(OctoVirtual.OctoVirtualVector virtualVector)
            {
                if (virtualVector != null)
                    Set(virtualVector.Value);
                else if (OctoCore.Instance.Development.Log)
                    Debug.Log($"OctoVirtualVector is null");
            }
        }
    
        public DataBool[] Booleans;
        public DataInt[] Integers;
        public DataFloat[] Floats;
        public DataString[] Strings;
        public DataVector[] Vectors;
    
        private Dictionary<string, int> _booleansId;
        private Dictionary<string, int> _integersId;
        private Dictionary<string, int> _floatsId;
        private Dictionary<string, int> _stringsId;
        private Dictionary<string, int> _vectorsId;
    
        public void Init(OctoSettings settings)
        {
            if (!settings)
            {
                Debug.Log("No Settings Registered.");
                return;
            }
    
    #if UNITY_EDITOR
            // Get all data
            settings.GetAllDatas();
    #endif
    
            // Init values
    
            List<DataBool> tmpBooleans = new List<DataBool>();
            List<DataInt> tmpIntegers = new List<DataInt>();
            List<DataFloat> tmpFloats = new List<DataFloat>();
            List<DataString> tmpStrings = new List<DataString>();
            List<DataVector> tmpVectors = new List<DataVector>();
    
            foreach (global::OctoCore.Save.Data.OctoDataBool dataBool in settings.Save.Booleans)
                tmpBooleans.Add(new DataBool() { Id = dataBool.Id, Data = dataBool, Value = dataBool.Value });
    
            foreach (global::OctoCore.Save.Data.OctoDataInt dataInt in settings.Save.Integers)
                tmpIntegers.Add(new DataInt() { Id = dataInt.Id, Data = dataInt, Value = dataInt.Value });
    
            foreach (global::OctoCore.Save.Data.OctoDataFloat dataFloat in settings.Save.Floats)
                tmpFloats.Add(new DataFloat() { Id = dataFloat.Id, Data = dataFloat, Value = dataFloat.Value });
    
            foreach (global::OctoCore.Save.Data.OctoDataString dataString in settings.Save.Strings)
                tmpStrings.Add(new DataString() { Id = dataString.Id, Data = dataString, Value = dataString.Value });
    
            foreach (global::OctoCore.Save.Data.OctoDataVector dataVector in settings.Save.Vectors)
                tmpVectors.Add(new DataVector() { Id = dataVector.Id, Data = dataVector, Value = dataVector.Value });
    
            Booleans = tmpBooleans.ToArray();
            Integers = tmpIntegers.ToArray();
            Floats = tmpFloats.ToArray();
            Strings = tmpStrings.ToArray();
            Vectors = tmpVectors.ToArray();
    
            tmpBooleans.Clear();
            tmpIntegers.Clear();
            tmpFloats.Clear();
            tmpStrings.Clear();
            tmpVectors.Clear();
    
            // Load values
    
            Load();
    
            // Adress datas
    
            _booleansId = new Dictionary<string, int>();
            _integersId = new Dictionary<string, int>();
            _floatsId = new Dictionary<string, int>();
            _stringsId = new Dictionary<string, int>();
            _vectorsId = new Dictionary<string, int>();
    
            for (int i = 0; i < Booleans.Length; i++)
                _booleansId.Add(Booleans[i].Id, i);
    
            for (int i = 0; i < Integers.Length; i++)
                _integersId.Add(Integers[i].Id, i);
    
            for (int i = 0; i < Floats.Length; i++)
                _floatsId.Add(Floats[i].Id, i);
    
            for (int i = 0; i < Strings.Length; i++)
                _stringsId.Add(Strings[i].Id, i);
    
            for (int i = 0; i < Vectors.Length; i++)
                _vectorsId.Add(Vectors[i].Id, i);

            // Callback OctoEvents

            if (OctoEvents.Instance)
                OctoEvents.Instance.SetSaveInitialized();
        }
    
        public void Tick()
        {
    
        }
    
        public void OnSceneChanged(Scene current, Scene next)
        {
    
        }
    
        public void OnQuit()
        {
            Upgrade();
        }
    
        public void Load()
        {
            string path = GetPath();
    
            bool saveLoaded = false;
    
            if (File.Exists(path))
            {
                OctoVirtual virtualSave = new OctoVirtual
                {
                    Booleans = ReadGroup<OctoVirtual.OctoVirtualBool>(path, "Booleans"),
                    Integers = ReadGroup<OctoVirtual.OctoVirtualInt>(path, "Integers"),
                    Floats = ReadGroup<OctoVirtual.OctoVirtualFloat>(path, "Floats"),
                    Strings = ReadGroup<OctoVirtual.OctoVirtualString>(path, "Strings"),
                    Vectors = ReadGroup<OctoVirtual.OctoVirtualVector>(path, "Vectors")
                };
    
                foreach (DataBool dataBool in Booleans)
                    dataBool.Set(virtualSave.Booleans.Where(v => v.Id == dataBool.Id).FirstOrDefault());
    
                foreach (DataInt dataInt in Integers)
                    dataInt.Set(virtualSave.Integers.Where(v => v.Id == dataInt.Id).FirstOrDefault());
    
                foreach (DataFloat dataFloat in Floats)
                    dataFloat.Set(virtualSave.Floats.Where(v => v.Id == dataFloat.Id).FirstOrDefault());
    
                foreach (DataString dataString in Strings)
                    dataString.Set(virtualSave.Strings.Where(v => v.Id == dataString.Id).FirstOrDefault());
    
                foreach (DataVector dataVector in Vectors)
                    dataVector.Set(virtualSave.Vectors.Where(v => v.Id == dataVector.Id).FirstOrDefault());
    
                saveLoaded = true;
    
                if (OctoCore.Instance.Development.Log)
                {
                    if (saveLoaded) Debug.Log($"Save read from: {path}");
                    else Debug.Log($"Save corrupted: {path}");
                }
            }
            else if (OctoCore.Instance.Development.Log)
            {
                Debug.Log($"No save found at: {path}");
            }
    
            T[] ReadGroup<T>(string xmlPath, string groupName) where T : OctoVirtual, new()
            {
                List<T> list = new List<T>();
    
            using (XmlReader reader = XmlReader.Create(xmlPath))
                {
                    // Jump to node <groupName>
    
                    while (reader.Read())
                    {
                        if (reader.NodeType == XmlNodeType.Element && reader.Name == groupName)
                        {
                            string id = null;
                            string value = null;
    
                            while (reader.Read())
                            {
                                // Stop if end of group reached
    
                                if (reader.NodeType == XmlNodeType.EndElement && reader.Name == groupName)
                                    break;
    
                                if (reader.NodeType == XmlNodeType.Element)
                                {
                                    if (reader.Name == "ID")
                                        id = reader.ReadElementContentAsString();
                                    else if (reader.Name == "Value")
                                        value = reader.ReadElementContentAsString();
    
                                    // Create entry
    
                                    if (id != null && value != null)
                                    {
                                        T entry = new T { Id = id };
    
                                        switch (entry)
                                        {
                                            case OctoVirtual.OctoVirtualBool virtualBool:
                                                virtualBool.Value = bool.Parse(value);
                                                break;
    
                                            case OctoVirtual.OctoVirtualInt virtualInt:
                                                virtualInt.Value = int.Parse(value);
                                                break;
    
                                            case OctoVirtual.OctoVirtualFloat virtualFloat:
                                                virtualFloat.Value = float.Parse(value);
                                                break;
    
                                            case OctoVirtual.OctoVirtualString virtualString:
                                                virtualString.Value = value;
                                                break;
    
                                            case OctoVirtual.OctoVirtualVector virtualVector:
                                                virtualVector.Value = StringToVector4(value);
                                                break;
                                        }
    
                                        list.Add(entry);
                                        id = null;
                                        value = null;
                                    }
                                }
                            }
    
                            break;
                        }
                    }
                }
    
                return list.ToArray();
            }
    
            Vector4 StringToVector4(string s)
            {
                s = s.Trim('(', ')').Replace(" ", "");
    
                string[] parts = s.Split(',');
    
                if (parts.Length != 4)
                {
                    return Vector4.zero;
                }
                else
                {
                    return new Vector4(
                        float.Parse(parts[0], CultureInfo.InvariantCulture),
                        float.Parse(parts[1], CultureInfo.InvariantCulture),
                        float.Parse(parts[2], CultureInfo.InvariantCulture),
                        float.Parse(parts[3], CultureInfo.InvariantCulture)
                    );
                }
            }
        }
    
        public void Upgrade()
        {
            // Set virtual save
    
            OctoVirtual virtualSave = new OctoVirtual()
            {
                Booleans = new OctoVirtual.OctoVirtualBool[Booleans.Length],
                Integers = new OctoVirtual.OctoVirtualInt[Integers.Length],
                Floats = new OctoVirtual.OctoVirtualFloat[Floats.Length],
                Strings = new OctoVirtual.OctoVirtualString[Strings.Length],
                Vectors = new OctoVirtual.OctoVirtualVector[Vectors.Length]
            };
    
            for (int i = 0; i < virtualSave.Booleans.Length; i++)
            {
                virtualSave.Booleans[i] = new OctoVirtual.OctoVirtualBool();
                virtualSave.Booleans[i].Id = Booleans[i].Id;
                virtualSave.Booleans[i].Value = Booleans[i].Value;
            }
    
            for (int i = 0; i < virtualSave.Integers.Length; i++)
            {
                virtualSave.Integers[i] = new OctoVirtual.OctoVirtualInt();
                virtualSave.Integers[i].Id = Integers[i].Id;
                virtualSave.Integers[i].Value = Integers[i].Value;
            }
    
            for (int i = 0; i < virtualSave.Floats.Length; i++)
            {
                virtualSave.Floats[i] = new OctoVirtual.OctoVirtualFloat();
                virtualSave.Floats[i].Id = Floats[i].Id;
                virtualSave.Floats[i].Value = Floats[i].Value;
            }
    
            for (int i = 0; i < virtualSave.Strings.Length; i++)
            {
                virtualSave.Strings[i] = new OctoVirtual.OctoVirtualString();
                virtualSave.Strings[i].Id = Strings[i].Id;
                virtualSave.Strings[i].Value = Strings[i].Value;
            }
    
            for (int i = 0; i < virtualSave.Vectors.Length; i++)
            {
                virtualSave.Vectors[i] = new OctoVirtual.OctoVirtualVector();
                virtualSave.Vectors[i].Id = Vectors[i].Id;
                virtualSave.Vectors[i].Value = Vectors[i].Value;
            }
    
            // Save file
    
            string path = GetPath();
    
        using (XmlWriter writer = XmlWriter.Create(path, new XmlWriterSettings { Indent = true }))
            {
                writer.WriteStartDocument();
                writer.WriteStartElement("OctoSave");
    
                void WriteGroup<T>(string groupName, T[] array) where T : OctoVirtual
                {
                    if (array == null || array.Length == 0) return;
    
                    writer.WriteStartElement(groupName);
    
                    foreach (var item in array)
                    {
                        writer.WriteElementString("ID", item.Id);
    
                        switch (item)
                        {
                            case OctoVirtual.OctoVirtualBool virtualBool:
                                writer.WriteElementString("Value", virtualBool.Value.ToString().ToLower());
                                break;
    
                            case OctoVirtual.OctoVirtualInt virtualInt:
                                writer.WriteElementString("Value", virtualInt.Value.ToString());
                                break;
    
                            case OctoVirtual.OctoVirtualFloat virtualFloat:
                                writer.WriteElementString("Value", virtualFloat.Value.ToString());
                                break;
    
                            case OctoVirtual.OctoVirtualString virtualString:
                                writer.WriteElementString("Value", virtualString.Value);
                                break;
    
                            case OctoVirtual.OctoVirtualVector virtualVector:
                                writer.WriteElementString("Value", virtualVector.Value.ToString());
                                break;
                        }
                    }
    
                    writer.WriteEndElement();
                }
    
                WriteGroup("Booleans", virtualSave.Booleans);
                WriteGroup("Integers", virtualSave.Integers);
                WriteGroup("Floats", virtualSave.Floats);
                WriteGroup("Strings", virtualSave.Strings);
                WriteGroup("Vectors", virtualSave.Vectors);
    
                writer.WriteEndElement();
                writer.WriteEndDocument();
            }
    
            if (OctoCore.Instance.Development.Log) Debug.Log($"Saved to: {path}");
        }
    
        public void Unsubscribe<T>(global::OctoCore.Save.Data.OctoData data, Action<T> action)
        {
            Subscribe(data, action, false);
        }
    
        public void Subscribe<T>(global::OctoCore.Save.Data.OctoData data, Action<T> handler, bool subscribe = true)
        {
            if (data == null || string.IsNullOrEmpty(data.Id))
            {
                if (OctoCore.Instance.Development.Log)
                    Debug.Log("Data is null or has no ID");
                return;
            }
    
            switch (data)
            {
                case global::OctoCore.Save.Data.OctoDataBool _ when _booleansId.TryGetValue(data.Id, out int iBool):
                    if (subscribe) Booleans[iBool].OnValueChanged += handler as Action<bool>;
                    else Booleans[iBool].OnValueChanged -= handler as Action<bool>;
                    break;
    
                case global::OctoCore.Save.Data.OctoDataInt _ when _integersId.TryGetValue(data.Id, out int iInt):
                    if (subscribe) Integers[iInt].OnValueChanged += handler as Action<int>;
                    else Integers[iInt].OnValueChanged -= handler as Action<int>;
                    break;
    
                case global::OctoCore.Save.Data.OctoDataFloat _ when _floatsId.TryGetValue(data.Id, out int iFloat):
                    if (subscribe) Floats[iFloat].OnValueChanged += handler as Action<float>;
                    else Floats[iFloat].OnValueChanged -= handler as Action<float>;
                    break;
    
                case global::OctoCore.Save.Data.OctoDataString _ when _stringsId.TryGetValue(data.Id, out int iString):
                    if (subscribe) Strings[iString].OnValueChanged += handler as Action<string>;
                    else Strings[iString].OnValueChanged -= handler as Action<string>;
                    break;
    
                case global::OctoCore.Save.Data.OctoDataVector _ when _vectorsId.TryGetValue(data.Id, out int iVector):
                    if (subscribe) Vectors[iVector].OnValueChanged += handler as Action<Vector4>;
                    else Vectors[iVector].OnValueChanged -= handler as Action<Vector4>;
                    break;
    
                default:
                    if (OctoCore.Instance.Development.Log)
                        Debug.Log($"Unsupported or missing data: {data.Id}");
                    break;
            }
        }
    
        #region GET
    
        public bool Get(global::OctoCore.Save.Data.OctoDataBool dataBool)
        {
            if (dataBool)
            {
                if (_booleansId.ContainsKey(dataBool.Id))
                {
                    return Booleans[_booleansId[dataBool.Id]].Value;
                }
                else if (OctoCore.Instance.Development.Log)
                {
                    Debug.Log($"Bool data not found: {dataBool.Id}");
                }
            }
            else if (OctoCore.Instance.Development.Log)
            {
                Debug.Log($"Bool data is null");
            }
    
            return false;
        }
    
        public int Get(global::OctoCore.Save.Data.OctoDataInt dataInt)
        {
            if (dataInt)
            {
                if (_integersId.ContainsKey(dataInt.Id))
                {
                    return Integers[_integersId[dataInt.Id]].Value;
                }
                else if (OctoCore.Instance.Development.Log)
                {
                    Debug.Log($"Int data not found: {dataInt.Id}");
                }
            }
            else if (OctoCore.Instance.Development.Log)
            {
                Debug.Log($"Int data is null");
            }
    
            return 0;
        }
    
        public float Get(global::OctoCore.Save.Data.OctoDataFloat dataFloat)
        {
            if (dataFloat)
            {
                if (_floatsId.ContainsKey(dataFloat.Id))
                {
                    return Floats[_floatsId[dataFloat.Id]].Value;
                }
                else if (OctoCore.Instance.Development.Log)
                {
                    Debug.Log($"Int data not found: {dataFloat.Id}");
                }
            }
            else if (OctoCore.Instance.Development.Log)
            {
                Debug.Log($"Int data is null");
            }
    
            return 0;
        }
    
        public string Get(global::OctoCore.Save.Data.OctoDataString dataString)
        {
            if (dataString)
            {
                if (_stringsId.ContainsKey(dataString.Id))
                {
                    return Strings[_stringsId[dataString.Id]].Value;
                }
                else if (OctoCore.Instance.Development.Log)
                {
                    Debug.Log($"Int data not found: {dataString.Id}");
                }
            }
            else if (OctoCore.Instance.Development.Log)
            {
                Debug.Log($"Int data is null");
            }
    
            return string.Empty;
        }
    
        public Vector4 Get(global::OctoCore.Save.Data.OctoDataVector dataVector)
        {
            if (dataVector)
            {
                if (_vectorsId.ContainsKey(dataVector.Id))
                {
                    return Vectors[_vectorsId[dataVector.Id]].Value;
                }
                else if (OctoCore.Instance.Development.Log)
                {
                    Debug.Log($"Vector data not found: {dataVector.Id}");
                }
            }
            else if (OctoCore.Instance.Development.Log)
            {
                Debug.Log($"Vector data is null");
            }
    
            return Vector4.zero;
        }
    
        public bool GetBool(string id)
        {
            if (_booleansId.ContainsKey(id))
            {
                return Booleans[_booleansId[id]].Value;
            }
            else if (OctoCore.Instance.Development.Log)
            {
                Debug.Log($"Bool data not found: {id}");
            }
    
            return false;
        }
    
        public int GetInt(string id)
        {
            if (_integersId.ContainsKey(id))
            {
                return Integers[_integersId[id]].Value;
            }
            else if (OctoCore.Instance.Development.Log)
            {
                Debug.Log($"Int data not found: {id}");
            }
    
            return 0;
        }
    
        public float GetFloat(string id)
        {
            if (_floatsId.ContainsKey(id))
            {
                return Floats[_floatsId[id]].Value;
            }
            else if (OctoCore.Instance.Development.Log)
            {
                Debug.Log($"Float data not found: {id}");
            }
    
            return 0;
        }
    
        public string GetString(string id)
        {
            if (_stringsId.ContainsKey(id))
            {
                return Strings[_stringsId[id]].Value;
            }
            else if (OctoCore.Instance.Development.Log)
            {
                Debug.Log($"String data not found: {id}");
            }
    
            return string.Empty;
        }
    
        public Vector4 GetVector(string id)
        {
            if (_vectorsId.ContainsKey(id))
            {
                return Vectors[_vectorsId[id]].Value;
            }
            else if (OctoCore.Instance.Development.Log)
            {
                Debug.Log($"String data not found: {id}");
            }
    
            return Vector4.zero;
        }
    
        #endregion
    
        #region SET
    
        public void Set(global::OctoCore.Save.Data.OctoDataBool dataBool, bool value)
        {
            if (dataBool != null && _booleansId.ContainsKey(dataBool.Id))
            {
                Booleans[_booleansId[dataBool.Id]].Set(value);
            }
            else if (OctoCore.Instance.Development.Log)
            {
                Debug.Log($"Bool data is null or not found");
            }
        }
    
        public void Set(global::OctoCore.Save.Data.OctoDataInt dataInt, int value)
        {
            if (dataInt != null && _integersId.ContainsKey(dataInt.Id))
            {
                Integers[_integersId[dataInt.Id]].Set(value);
            }
            else if (OctoCore.Instance.Development.Log)
            {
                Debug.Log($"Int data is null or not found");
            }
        }
    
        public void Set(global::OctoCore.Save.Data.OctoDataFloat dataFloat, float value)
        {
            if (dataFloat != null && _floatsId.ContainsKey(dataFloat.Id))
            {
                Floats[_floatsId[dataFloat.Id]].Set(value);
            }
            else if (OctoCore.Instance.Development.Log)
            {
                Debug.Log($"Float data is null or not found");
            }
        }
    
        public void Set(global::OctoCore.Save.Data.OctoDataString dataString, string value)
        {
            if (dataString != null && _stringsId.ContainsKey(dataString.Id))
            {
                Strings[_stringsId[dataString.Id]].Set(value);
            }
            else if (OctoCore.Instance.Development.Log)
            {
                Debug.Log($"String data is null or not found");
            }
        }
    
        public void Set(global::OctoCore.Save.Data.OctoDataVector dataVector, Vector4 value)
        {
            if (dataVector != null && _vectorsId.ContainsKey(dataVector.Id))
            {
                Vectors[_vectorsId[dataVector.Id]].Set(value);
            }
            else if (OctoCore.Instance.Development.Log)
            {
                Debug.Log($"Vector data is null or not found");
            }
        }
    
        public void SetBool(string id, bool value)
        {
            if (_booleansId.ContainsKey(id))
            {
                Booleans[_booleansId[id]].Set(value);
            }
            else if (OctoCore.Instance.Development.Log)
            {
                Debug.Log($"Bool data not found: {id}");
            }
        }
    
        public void SetInt(string id, int value)
        {
            if (_booleansId.ContainsKey(id))
            {
                Integers[_integersId[id]].Set(value);
            }
            else if (OctoCore.Instance.Development.Log)
            {
                Debug.Log($"Int data not found: {id}");
            }
        }
    
        public void SetFloat(string id, float value)
        {
            if (_floatsId.ContainsKey(id))
            {
                Floats[_floatsId[id]].Set(value);
            }
            else if (OctoCore.Instance.Development.Log)
            {
                Debug.Log($"Float data not found: {id}");
            }
        }
    
        public void SetString(string id, string value)
        {
            if (_stringsId.ContainsKey(id))
            {
                Strings[_stringsId[id]].Set(value);
            }
            else if (OctoCore.Instance.Development.Log)
            {
                Debug.Log($"String data not found: {id}");
            }
        }
    
        public void SetVector(string id, Vector4 value)
        {
            if (_vectorsId.ContainsKey(id))
            {
                Vectors[_vectorsId[id]].Set(value);
            }
            else if (OctoCore.Instance.Development.Log)
            {
                Debug.Log($"String data not found: {id}");
            }
        }
    
        #endregion
    
        private string GetPath()
        {
            Platform.OctoPlatforms platform = OctoCore.Instance ? OctoCore.Instance.Platform.Current : Platform.OctoPlatforms.Standalone;
    
            switch (platform)
            {
                default:
                    return Path.Combine(Application.persistentDataPath, "Save.xml");
    
                case Platform.OctoPlatforms.XboxOne:
                    return Path.Combine(Application.persistentDataPath, "Save.xml");
    
                case Platform.OctoPlatforms.XboxSeries:
                    return Path.Combine(Application.persistentDataPath, "Save.xml");
    
                case Platform.OctoPlatforms.PS4:
                    return Path.Combine(Application.persistentDataPath, "Save.xml");
    
                case Platform.OctoPlatforms.PS5:
                    return Path.Combine(Application.persistentDataPath, "Save.xml");
    
                case Platform.OctoPlatforms.Switch:
                    return Path.Combine(Application.persistentDataPath, "Save.xml");
            }
        }
    }
}