AuxiliaryData.cs

/*
 * NanoXLSX is a small .NET library to generate and read XLSX (Microsoft Excel 2007 or newer) files in an easy and native way  
 * Copyright Raphael Stoeckli © 2026
 * This library is licensed under the MIT License.
 * You find a copy of the license in project folder or on: http://opensource.org/licenses/MIT
 */
 
using System.Collections.Generic;
using System.Linq;
using NanoXLSX.Utils;
 
namespace NanoXLSX
{
    internal class AuxiliaryData
    {
        private const string DEFAULT_ENTITY_ID = "";
 
        // Structure: PlugInId => EntityId => SubEntityId => value
        private readonly Dictionary<string, Dictionary<string, Dictionary<string, DataEntry>>> data
            = new Dictionary<string, Dictionary<string, Dictionary<string, DataEntry>>>();

        public void SetData(string plugInId, int valueId, object value, bool persistent = false)
        {
            string id = ParserUtils.ToString(valueId);
            SetData(plugInId, id, value, persistent);
        }

        public void SetData(string plugInId, int entityId, string valueId, object value, bool persistent = false)
        {
            string id = ParserUtils.ToString(entityId);
            SetData(plugInId, id, valueId, value, persistent);
        }

        public void SetData(string plugInId, string valueId, object value, bool persistent = false)
        {
            SetData(plugInId, DEFAULT_ENTITY_ID, valueId, value, persistent);
        }

        public void SetData(string plugInId, string entityId, int valueId, object value, bool persistent = false)
        {
            string id = ParserUtils.ToString(valueId);
            SetData(plugInId, entityId, id, value, persistent);
        }

        public void SetData(string plugInId, string entityId, string valueId, object value, bool persistent = false)
        {
            if (!data.TryGetValue(plugInId, out Dictionary<string, Dictionary<string, DataEntry>> pluginData))
            {
                pluginData = new Dictionary<string, Dictionary<string, DataEntry>>();
                data[plugInId] = pluginData;
            }
 
            if (!pluginData.TryGetValue(entityId, out Dictionary<string, DataEntry> entityData))
            {
                entityData = new Dictionary<string, DataEntry>();
                pluginData[entityId] = entityData;
            }
 
            entityData[valueId] = new DataEntry(value, persistent);
        }

        public object GetData(string plugInId, int valueId)
        {
            string id = ParserUtils.ToString(valueId);
            return GetData(plugInId, id);
        }

        public object GetData(string plugInId, string valueId)
        {
            return GetData(plugInId, DEFAULT_ENTITY_ID, valueId);
        }

        public object GetData(string plugInId, int entityId, string valueId)
        {
            string id = ParserUtils.ToString(entityId);
            return GetData(plugInId, id, valueId);
        }

        public object GetData(string plugInId, string entityId, string valueId)
        {
            if (data.TryGetValue(plugInId, out Dictionary<string, Dictionary<string, DataEntry>> pluginData) &&
                pluginData.TryGetValue(entityId, out Dictionary<string, DataEntry> entityData) &&
                entityData.TryGetValue(valueId, out DataEntry entry))
            {
                return entry.Value;
            }
            return null;
        }

        public T GetData<T>(string plugInId, int valueId)
        {
            string id = ParserUtils.ToString(valueId);
            return GetData<T>(plugInId, id);
        }

        public T GetData<T>(string plugInId, string valueId)
        {
            return GetData<T>(plugInId, DEFAULT_ENTITY_ID, valueId);
        }

        public T GetData<T>(string plugInId, string entityId, int valueId)
        {
            string id = ParserUtils.ToString(valueId);
            return GetData<T>(plugInId, entityId, id);
        }

        public T GetData<T>(string plugInId, string entityId, string valueId)
        {
            object value = GetData(plugInId, entityId, valueId);
            return value is T ? (T)value : default;
        }
 
        public List<T> GetDataList<T>(string plugInId)
        {
            return GetDataList<T>(plugInId, DEFAULT_ENTITY_ID);
        }
 
        public List<T> GetDataList<T>(string plugInId, string entityId)
        {
            List<T> result = new List<T>();
            if (data.TryGetValue(plugInId, out Dictionary<string, Dictionary<string, DataEntry>> pluginData) &&
                pluginData.TryGetValue(entityId, out Dictionary<string, DataEntry> entityData))
            {
                foreach (KeyValuePair<string, DataEntry> entry in entityData)
                {
                    if (entry.Value.Value is T value)
                    {
                        result.Add(value);
                    }
                }
            }
            return result;
        }

        public bool RemoveEntityData(string plugInId, string entityId, string valueId)
        {
            if (!data.TryGetValue(plugInId, out Dictionary<string, Dictionary<string, DataEntry>> pluginData) ||
                !pluginData.TryGetValue(entityId, out Dictionary<string, DataEntry> entityData) ||
                !entityData.Remove(valueId))
            {
                return false;
            }
 
            if (entityData.Count == 0)
            {
                pluginData.Remove(entityId);
            }
            if (pluginData.Count == 0)
            {
                data.Remove(plugInId);
            }
            return true;
        }

        public bool RemoveEntityData(string plugInId, string entityId, int valueId)
        {
            string id = ParserUtils.ToString(valueId);
            return RemoveEntityData(plugInId, entityId, id);
        }

        public bool RemoveEntityData(string plugInId, string entityId, object obj)
        {
            if (data.TryGetValue(plugInId, out Dictionary<string, Dictionary<string, DataEntry>> pluginData) &&
                pluginData.TryGetValue(entityId, out Dictionary<string, DataEntry> entityData))
            {
                foreach (KeyValuePair<string, DataEntry> entry in entityData)
                {
                    if (ReferenceEquals(entry.Value.Value, obj))
                    {
                        return RemoveEntityData(plugInId, entityId, entry.Key);
                    }
                }
            }
            return false;
        }

        public void ClearEntityData(string plugInId, string entityId)
        {
            if (data.TryGetValue(plugInId, out Dictionary<string, Dictionary<string, DataEntry>> pluginData))
            {
                pluginData.Remove(entityId);
                if (pluginData.Count == 0)
                {
                    data.Remove(plugInId);
                }
            }
        }

        public void ClearTemporaryData()
        {
            foreach (KeyValuePair<string, Dictionary<string, Dictionary<string, DataEntry>>> pluginPair in data.ToList())
            {
                Dictionary<string, Dictionary<string, DataEntry>> pluginData = pluginPair.Value;
                foreach (KeyValuePair<string, Dictionary<string, DataEntry>> entityPair in pluginData.ToList())
                {
                    Dictionary<string, DataEntry> entityData = entityPair.Value;
                    List<string> keysToRemove = new List<string>();
                    foreach (KeyValuePair<string, DataEntry> kvp in entityData)
                    {
                        if (!kvp.Value.Persistent)
                        {
                            keysToRemove.Add(kvp.Key);
                        }
                    }
                    foreach (string key in keysToRemove)
                    {
                        entityData.Remove(key);
                    }
                    if (entityData.Count == 0)
                    {
                        pluginData.Remove(entityPair.Key);
                    }
                }
                if (pluginData.Count == 0)
                {
                    data.Remove(pluginPair.Key);
                }
            }
        }

        public void ClearData()
        {
            data.Clear();
        }

        private class DataEntry
        {
            public object Value { get; }
            public bool Persistent { get; }

            public DataEntry(object value, bool persistent)
            {
                Value = value;
                Persistent = persistent;
            }
        }
 
    }
}