//-----------------------------------------------------------------------
// <copyright file="StackedDictionary.cs" company="bedug.com">
//     Copyright © 2012 Nils Hammar. All rights reserved.
// </copyright>
//-----------------------------------------------------------------------
/*
 * Software to access vehicle information via the OBD-II connector.
 * 
 * Copyright © 2012 Nils Hammar
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 * 
 * Alternative licensing is possible, see the licensing document.
 * 
 * The above text may not be removed or modified.
 */

namespace SharedObjects.Misc
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;

    /// <summary>
    /// Class that allows for long composite keys to data in a dictionary,
    /// which allows for multi-dimensional keys using recursion.
    /// <para>
    /// Be aware that this can cause large allocations of memory.
    /// </para>
    /// </summary>
    /// <typeparam name="TK">Type of key array.</typeparam>
    /// <typeparam name="TV">Type of value.</typeparam>
    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1711:IdentifiersShouldNotHaveIncorrectSuffix", Justification = "Correct for this implementation.")]
    public class StackedDictionary<TK, TV>
    {
        /// <summary>
        /// Root hashtable implementing the stacked dictionary.
        /// </summary>
        private Hashtable hashtable = new Hashtable();

        /// <summary>
        /// Initializes a new instance of the <see cref="StackedDictionary{TK,TV}" /> class.
        /// </summary>
        public StackedDictionary()
        {
        }

        /// <summary>
        /// Clear the dictionary from all data.
        /// <para>
        /// Notice that this relies on garbage collection to free memory.
        /// </para>
        /// </summary>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2001:AvoidCallingProblematicMethods", MessageId = "System.GC.Collect", Justification = "Reviewed, Intentional.")]
        public void Clear()
        {
            this.hashtable.Clear();
            System.GC.Collect();
        }

        /// <summary>
        /// Get a list of all keys present in the dictionary.
        /// </summary>
        /// <returns>List with arrays of key values.</returns>
        public IList<TK[]> GetKeys()
        {
            IList<TK[]> keyList = new List<TK[]>();

            IList<TK> l1 = new List<TK>();
            GetKeys(this.hashtable, keyList, l1);

            return keyList;
        }

        /// <summary>
        /// Add one data item with the given key.
        /// </summary>
        /// <param name="keys">Array of key values.</param>
        /// <param name="value">Value to add.</param>
        public void Add(TK[] keys, TV value)
        {
            if (keys != null)
            {
                int levels = keys.Length;

                Add(this.hashtable, keys, 0, levels, value);
            }
        }

        /// <summary>
        /// Get value for the given key.
        /// </summary>
        /// <param name="keys">Array of key values.</param>
        /// <returns>The value for the given key.</returns>
        public TV Get(TK[] keys)
        {
            TV data = default(TV);

            if (keys != null)
            {
                int levels = keys.Length;

                data = Get(this.hashtable, keys, 0, levels);
            }

            return data;
        }

        /// <summary>
        /// Replace value on item with the given key.
        /// </summary>
        /// <param name="keys">Array of key values.</param>
        /// <param name="value">Value to set.</param>
        public void Set(TK[] keys, TV value)
        {
            if (keys != null)
            {
                int levels = keys.Length;

                Set(this.hashtable, keys, 0, levels, value);
            }
        }

        /// <summary>
        /// Recursively populate the list of key arrays.
        /// </summary>
        /// <param name="hashtable">Hashtable with data.</param>
        /// <param name="keyList">Kay list to populate.</param>
        /// <param name="l0">Current key base.</param>
        private static void GetKeys(Hashtable hashtable, IList<TK[]> keyList, IList<TK> l0)
        {
            foreach (object keyObj in hashtable.Keys)
            {
                TK key = (TK)keyObj;
                IList<TK> l1 = new List<TK>(l0);
                l1.Add(key);
                if (hashtable[key] is Hashtable)
                {
                    GetKeys((Hashtable)hashtable[key], keyList, l1);
                }
                else
                {
                    keyList.Add(l1.ToArray());
                }
            }
        }

        /// <summary>
        /// Recursively get the value for the given key.
        /// </summary>
        /// <param name="hashtable">Hashtable with data.</param>
        /// <param name="keys">Array of key values.</param>
        /// <param name="level">Current recursion level.</param>
        /// <param name="levels">Max recursion level.</param>
        /// <returns>Stored value.</returns>
        private static TV Get(Hashtable hashtable, TK[] keys, int level, int levels)
        {
            TV data = default(TV);

            if (hashtable.ContainsKey(keys[level]))
            {
                if (level == levels - 1)
                {
                    if (hashtable[keys[level]] is TV)
                    {
                        data = (TV)hashtable[keys[level]];
                    }
                }
                else
                {
                    data = Get((Hashtable)hashtable[keys[level]], keys, level + 1, levels);
                }
            }

            return data;
        }

        /// <summary>
        /// Recursively update the value indicated by the given key.
        /// </summary>
        /// <param name="hashtable">Hashtable with data.</param>
        /// <param name="keys">Array of key values.</param>
        /// <param name="level">Current recursion level.</param>
        /// <param name="levels">Max recursion level.</param>
        /// <param name="value">Value to set.</param>
        private static void Set(Hashtable hashtable, TK[] keys, int level, int levels, TV value)
        {
            if (hashtable.ContainsKey(keys[level]))
            {
                if (level == levels - 1)
                {
                    if (hashtable[keys[level]] is TV)
                    {
                        hashtable[keys[level]] = value;
                    }
                }
                else
                {
                    Set((Hashtable)hashtable[keys[level]], keys, level + 1, levels, value);
                }
            }
        }

        /// <summary>
        /// Recursively add a new value to the dictionary.
        /// </summary>
        /// <param name="hashtable">Hashtable with data.</param>
        /// <param name="keys">Array of key values.</param>
        /// <param name="level">Current recursion level.</param>
        /// <param name="levels">Max recursion level.</param>
        /// <param name="value">Value to set.</param>
        private static void Add(Hashtable hashtable, TK[] keys, int level, int levels, TV value)
        {
            if (level == levels - 1)
            {
                hashtable[keys[level]] = value;
            }
            else
            {
                if (!hashtable.ContainsKey(keys[level]))
                {
                    hashtable[keys[level]] = new Hashtable();
                }

                Add((Hashtable)hashtable[keys[level]], keys, level + 1, levels, value);
            }
        }
    }
}