using System;
using System.Collections;

namespace System.util.collections
{
    /// <summary>
    /// A HashTable with iterators
    /// </summary>
    public class k_HashTable : IMap
    {
        #region static helper functions

        private readonly static int[] mk_Primes = 
        {
            11, 17, 23, 29, 37, 47, 59, 71, 89, 107, 131, 163, 197, 239, 293, 353, 431, 521, 631, 761, 919,
            1103, 1327, 1597, 1931, 2333, 2801, 3371, 4049, 4861, 5839, 7013, 8419, 10103, 12143, 14591,
            17519, 21023, 25229, 30293, 36353, 43627, 52361, 62851, 75431, 90523, 108631, 130363, 
            156437, 187751, 225307, 270371, 324449, 389357, 467237, 560689, 672827, 807403,
            968897, 1162687, 1395263, 1674319, 2009191, 2411033, 2893249, 3471899, 4166287, 
            4999559, 5999471, 7199369 
        };

        private static bool IsPrime(int ai_Number) 
        {
            if ((ai_Number & 1) == 0) 
                return (ai_Number == 2);

            int li_Max = (int)Math.Sqrt(ai_Number);
            for (int li_Div=3; li_Div < li_Max; li_Div+=2)
            {
                if ((ai_Number % li_Div) == 0)
                    return false;
            }
            return true;
        }

        private static int FindPrimeGreater(int ai_Min)
        {
            if (ai_Min < 0)
                throw new ArgumentException("k_HashTable capacity overflow.");

            // do binary search lookup in primes array
            int li_Pos = Array.BinarySearch(mk_Primes, ai_Min);
            if (li_Pos >= 0)
                return mk_Primes[li_Pos];

            li_Pos = ~li_Pos;
            if (li_Pos < mk_Primes.Length)
                return mk_Primes[li_Pos];

            // ai_Min is greater than highest number in mk_Primes
            for (int i = (ai_Min|1); i <= Int32.MaxValue; i+=2)
            {
                if (IsPrime(i))
                    return i;
            }
            return ai_Min;
        }

        #endregion

        #region Bucket Structure

        private struct r_Bucket 
        {
            public object mk_Key;
            public object mk_Value;
            public int mi_HashCode;        // MSB (sign bit) indicates a collision.
        }

        #endregion

        #region k_BucketIterator Implementation

        private class k_BucketIterator : k_Iterator
        {
            private readonly k_HashTable mk_Table;
            private int mi_Index;

            public k_BucketIterator(k_HashTable ak_Table, int ai_Index)
            {
                mk_Table = ak_Table;
                mi_Index = -1;
                if (ai_Index >= 0)
                    mi_Index = FindNext(ai_Index-1);
            }

            public override object Current
            {
                get
                {
                    if (mi_Index < 0 || mk_Table.mk_Buckets[mi_Index].mk_Key == null)
                        throw new k_InvalidPositionException();

                    r_Bucket lr_Bucket = mk_Table.mk_Buckets[mi_Index];
                    return new DictionaryEntry(lr_Bucket.mk_Key, lr_Bucket.mk_Value);
                }
                set
                {
                    if (mi_Index < 0 || mk_Table.mk_Buckets[mi_Index].mk_Key == null)
                        throw new k_InvalidPositionException();

                    DictionaryEntry lr_Entry = (DictionaryEntry)value;
                    r_Bucket lr_Bucket = mk_Table.mk_Buckets[mi_Index];
                    if (mk_Table.mk_Comparer.Compare(lr_Entry.Key, lr_Bucket.mk_Key) != 0)
                        throw new ArgumentException("Key values must not be changed.");
                    mk_Table.mk_Buckets[mi_Index].mk_Value = lr_Entry.Value;
                }
            }

            public override void Move(int ai_Count)
            {
                int li_NewIndex = mi_Index;

                if (ai_Count > 0)
                {
                    while (ai_Count-- > 0)
                    {
                        if (li_NewIndex < 0)
                            throw new InvalidOperationException("Tried to moved beyond end element.");

                        li_NewIndex = FindNext(li_NewIndex);
                    }
                }
                else
                {
                    while (ai_Count++ < 0)
                    {
                        if (li_NewIndex < 0)
                            li_NewIndex = FindPrev(mk_Table.mk_Buckets.Length);
                        else
                            li_NewIndex = FindPrev(li_NewIndex);

                        if (li_NewIndex < 0)
                            throw new InvalidOperationException("Tried to move before first element.");
                    }
                }

                mi_Index = li_NewIndex;
            }

            public override int Distance(k_Iterator ak_Iter)
            {
                k_BucketIterator lk_Iter = ak_Iter as k_BucketIterator;
                if (lk_Iter == null || !object.ReferenceEquals(lk_Iter.Collection, this.Collection))
                    throw new ArgumentException("Cannot determine distance of iterators belonging to different collections.");
                
                k_Iterator lk_End = mk_Table.End;
    
                int li_IndexDiff; 
                if (this != lk_End && ak_Iter != lk_End)
                    li_IndexDiff = mi_Index - lk_Iter.mi_Index;
                else
                    li_IndexDiff = (this == lk_End) ? 1 : -1;    // 1 is also fine when both are End

                if (li_IndexDiff < 0)
                {
                    int li_Diff = 0;
                    k_Iterator lk_Bck = this.Clone(); 
                    for (; lk_Bck != ak_Iter && lk_Bck != lk_End; lk_Bck.Next())
                        --li_Diff;

                    if (lk_Bck == ak_Iter)
                        return li_Diff;
                } 
                else
                {
                    int li_Diff = 0;
                    k_Iterator lk_Fwd = ak_Iter.Clone(); 
                    for (; lk_Fwd != this && lk_Fwd != lk_End; lk_Fwd.Next())
                        ++li_Diff;

                    if (lk_Fwd == this)
                        return li_Diff;
                }
                
                throw new Exception("Inconsistent state. Concurrency?");
            }

            public override object Collection
            {
                get { return mk_Table; }
            }

            public override bool Equals(object ak_Obj)
            {
                k_BucketIterator lk_Iter = ak_Obj as k_BucketIterator;
                if (lk_Iter == null)
                    return false;

                return (mi_Index == lk_Iter.mi_Index && object.ReferenceEquals(mk_Table, lk_Iter.mk_Table));
            }

            public override int GetHashCode()
            {
                return mk_Table.GetHashCode() ^ mi_Index;
            }

            public override k_Iterator Clone()
            {
                return new k_BucketIterator(mk_Table, mi_Index);
            }

            private int FindPrev(int ai_Index)
            {
                --ai_Index;
                r_Bucket[] lk_Buckets = mk_Table.mk_Buckets;
                while (ai_Index >= 0 && lk_Buckets[ai_Index].mk_Key == null)
                    --ai_Index;
                if (ai_Index < -1)
                    return -1;
                return ai_Index;
            }

            private int FindNext(int ai_Index)
            {
                ++ai_Index;
                r_Bucket[] lk_Buckets = mk_Table.mk_Buckets;
                while (ai_Index < lk_Buckets.Length && lk_Buckets[ai_Index].mk_Key == null)
                    ++ai_Index;

                if (ai_Index >= lk_Buckets.Length)
                    return -1;
                return ai_Index;
            }

            internal int Index
            {
                get { return mi_Index; }
            }
        }

        private class k_PinnedBucketIterator : k_BucketIterator
        {
            public k_PinnedBucketIterator(k_HashTable ak_Table, int ai_Index)
                : base(ak_Table, ai_Index)
            {
            }

            public override void Move(int ai_Count)
            {
                throw new k_IteratorPinnedException();
            }
        }

        #endregion

        private IHashCodeProvider mk_HashProvider;
        private IComparer mk_Comparer;
        private double md_LoadFactor;
        private int mi_GrowSize;
        private r_Bucket[] mk_Buckets;
        private int mi_Count;
        private readonly k_Iterator mk_End;

        public k_HashTable()
            : this(0, 0.72)
        {
        }

        public k_HashTable(int ai_Capacity, double ad_LoadFactor)
            : this(ai_Capacity, ad_LoadFactor, null, null)
        {
        }

        public k_HashTable(int ai_Capacity, double ad_LoadFactor, IHashCodeProvider ak_HashProvider, IComparer ak_Comparer)
        {
            if (ad_LoadFactor <= .0 || ad_LoadFactor > 1.0)
                throw new ArgumentException("Load factor must be greater than .0 and smaller or equal to 1.0", "ad_LoadFactor");
            md_LoadFactor = ad_LoadFactor;
            
            double ld_Size = ai_Capacity/ad_LoadFactor;
            if (ld_Size > int.MaxValue)
                throw new ArgumentException("k_HashTable overflow");

            int li_TableSize = FindPrimeGreater((int)ld_Size);
            mk_Buckets = new r_Bucket[li_TableSize];
            mi_GrowSize = (md_LoadFactor < 1.0) ? (int)(md_LoadFactor * li_TableSize) : li_TableSize-1;
            
            mk_HashProvider = ak_HashProvider;
            mk_Comparer = ak_Comparer;

            mk_End = new k_PinnedBucketIterator(this, -1);
        }

        // IContainer Members
        public k_Iterator Begin
        {
            get 
            { 
                if (mi_Count == 0)
                    return mk_End;
                return new k_PinnedBucketIterator(this, 0);
            }
        }

        public k_Iterator End
        {
            get { return mk_End; }
        }

        public bool IsEmpty
        {
            get { return (mi_Count == 0); }
        }

        public k_Iterator Find(object ak_Value)
        {
            DictionaryEntry lr_Item = (DictionaryEntry)ak_Value;
            int li_Index = FindBucket(lr_Item.Key);
            if (li_Index < 0 || !object.Equals(mk_Buckets[li_Index].mk_Value, lr_Item.Value))
                return this.End;
            return new k_BucketIterator(this, li_Index);
        }

        public k_Iterator Erase(k_Iterator ak_Where)
        {
            //System.Diagnostics.Debug.Assert(object.ReferenceEquals(this, ak_Where.Collection), "Iterator does not belong to this collection.");
            k_Iterator lk_Successor = ak_Where + 1;
            EmptyBucket(((k_BucketIterator)ak_Where).Index);
            return lk_Successor;
        }

        public k_Iterator Erase(k_Iterator ak_First, k_Iterator ak_Last)
        {
            if (ak_First == this.Begin && ak_Last == this.End)
            {
                Clear();
                return ak_Last.Clone();
            }
            
            k_Iterator lk_Current = ak_First;
            while (lk_Current != ak_Last)
                lk_Current = Erase(lk_Current);
            return lk_Current;
        }

        // IMap Members
        public k_Iterator FindKey(object ak_Key)
        {
            return new k_BucketIterator(this, FindBucket(ak_Key));
        }

        public void Add(DictionaryEntry ar_Item)
        {
            Add(ar_Item.Key, ar_Item.Value);
        }

        public void Insert(k_Iterator ak_SrcBegin, k_Iterator ak_SrcEnd)
        {
            for (k_Iterator lk_Iter = ak_SrcBegin.Clone(); lk_Iter != ak_SrcEnd; lk_Iter.Next())
                Add((DictionaryEntry)lk_Iter.Current);
        }

        #region IDictionary Members

        public void Add(object ak_Key, object ak_Value)
        {
            SetValue(ak_Key, ak_Value, true);
        }

        public void Clear() 
        {
            if (mi_Count == 0)
                return;

            for (int i=0; i < mk_Buckets.Length; ++i)
                mk_Buckets[i] = new r_Bucket();

            mi_Count = 0;
        }

        public bool Contains(object ak_Key)
        {
            return (FindBucket(ak_Key) >= 0);
        }

        public void Remove(object ak_Key)
        {
            EmptyBucket(FindBucket(ak_Key));
        }

        public IDictionaryEnumerator GetEnumerator()
        {
            return new k_IteratorDictEnumerator(this.Begin, this.End);
        }

        public bool IsReadOnly
        {
            get { return false; }

        }
        public bool IsFixedSize
        {
            get { return false; }
        }

        public object this[object ak_Key]
        {
            get 
            {
                int li_Index = FindBucket(ak_Key);
                if (li_Index < 0)
                    return null;

                return mk_Buckets[li_Index].mk_Value;
            }
            set 
            {
                SetValue(ak_Key, value, false);
            }
        }

        public ICollection Keys
        {
            get
            {
                int i = 0;
                object[] lk_Keys = new object[mi_Count];
                foreach (DictionaryEntry lr_Entry in this)
                    lk_Keys[i++] = lr_Entry.Key;
                return lk_Keys;
            }
        }

        public ICollection Values
        {
            get
            {
                int i=0;
                object[] lk_Values = new object[mi_Count];
                foreach (DictionaryEntry lr_Entry in this)
                    lk_Values[i++] = lr_Entry.Value;
                return lk_Values;
            }
        }

        #endregion

        #region ICollection Members

        public void CopyTo(Array ak_Array, int ai_Index)
        {
            foreach (DictionaryEntry lr_Entry in this)
                ak_Array.SetValue(lr_Entry, ai_Index++);
        }

        public int Count
        {
            get { return mi_Count; }
        }

        public bool IsSynchronized
        {
            get { return false; }
        }

        public object SyncRoot
        {
            get { return this; }
        }

        #endregion

        #region IEnumerable Members

        IEnumerator System.Collections.IEnumerable.GetEnumerator()
        {
            return new k_IteratorEnumerator(this.Begin, this.End);
        }

        #endregion
        
        #region ICloneable Members

        public object Clone()
        {
            k_HashTable lk_Clone = new k_HashTable(this.Count, md_LoadFactor, mk_HashProvider, mk_Comparer);

            int i = mk_Buckets.Length;
            while (i-- > 0)
            {
                object lk_Key = mk_Buckets[i].mk_Key;
                if (lk_Key != null)
                    lk_Clone[lk_Key] = mk_Buckets[i].mk_Value;
            }
            return lk_Clone;
        }

        #endregion

        private void EmptyBucket(int ai_Index)
        {
            if (ai_Index < 0 || ai_Index >= mk_Buckets.Length)
                return;
            
            if (mk_Buckets[ai_Index].mk_Key == null)
                throw new InvalidOperationException("Key was removed earlier.");

            mk_Buckets[ai_Index].mi_HashCode &= unchecked((int)0x80000000);
            mk_Buckets[ai_Index].mk_Key = null;
            mk_Buckets[ai_Index].mk_Value = null;
            --mi_Count;
        }

        private int FindBucket(object ak_Key)
        {
            if (ak_Key == null)
                throw new ArgumentException("Key must not be null.", "ak_Key");

            uint lui_BucketCount = (uint)mk_Buckets.Length;

            uint lui_Increment;
            uint lui_HashCode = ComputeHashAndStep(ak_Key, out lui_Increment);
                
            uint lui_Walker = lui_HashCode % lui_BucketCount;
            r_Bucket lr_Bucket;
            do
            {
                int li_Index = (int)lui_Walker;
                lr_Bucket = mk_Buckets[li_Index];
                if (lr_Bucket.mk_Key == null && lr_Bucket.mi_HashCode >= 0)
                    break;    // stop on empty non-duplicate

                if ((lr_Bucket.mi_HashCode & 0x7fffffff) == lui_HashCode
                    && EqualsHelper(lr_Bucket.mk_Key, ak_Key))
                    return li_Index;

                lui_Walker += lui_Increment;
                lui_Walker %= lui_BucketCount;
            }
            while (lr_Bucket.mi_HashCode < 0 && lui_Walker != lui_HashCode);

            return -1;        // not found
        }

        private void SetValue(object ak_Key, object ak_Value, bool ab_Add)
        {
            if (mi_Count >= mi_GrowSize)
                ExpandBucketsArray();

            uint lui_BucketCount = (uint)mk_Buckets.Length;

            uint lui_Increment;
            uint lui_HashCode = ComputeHashAndStep(ak_Key, out lui_Increment);
                
            r_Bucket lr_Bucket;
            int li_Free = -1;
            uint lui_Walker = lui_HashCode % lui_BucketCount;
            do
            {
                int li_Index = (int)lui_Walker;
                lr_Bucket = mk_Buckets[li_Index];
                if (li_Free < 0 && lr_Bucket.mk_Key == null && lr_Bucket.mi_HashCode < 0)
                    li_Free = li_Index;

                if (lr_Bucket.mk_Key == null && (lr_Bucket.mi_HashCode & unchecked(0x80000000)) == 0)
                {
                    if (li_Free >= 0)
                        li_Index = li_Free;
                    mk_Buckets[li_Index].mk_Key = ak_Key;
                    mk_Buckets[li_Index].mk_Value = ak_Value;
                    mk_Buckets[li_Index].mi_HashCode |= (int)lui_HashCode;
                    ++mi_Count;
                    return;
                }

                if ((lr_Bucket.mi_HashCode & 0x7fffffff) == lui_HashCode
                    && EqualsHelper(lr_Bucket.mk_Key, ak_Key))
                {
                    if (ab_Add)
                        throw new ArgumentException("duplicate key");
                    mk_Buckets[li_Index].mk_Value = ak_Value;
                    return;
                }

                // mark all as dupes as long as we have not found a free bucket
                if (li_Free == -1)
                    mk_Buckets[li_Index].mi_HashCode |= unchecked((int)0x80000000);

                lui_Walker += lui_Increment;
                lui_Walker %= lui_BucketCount;
            }
            while (lui_Walker != lui_HashCode);

            if (li_Free == -1)
                throw new InvalidOperationException("Corrupted hash table. Insert failed.");

            mk_Buckets[li_Free].mk_Key = ak_Key;
            mk_Buckets[li_Free].mk_Value = ak_Value;
            mk_Buckets[li_Free].mi_HashCode |= (int)lui_HashCode;
            ++mi_Count;
        }

        private static void InternalExpandInsert(r_Bucket[] ak_Buckets, r_Bucket ar_Bucket)
        {
            ar_Bucket.mi_HashCode &= 0x7fffffff;
            uint lui_BucketCount = (uint)ak_Buckets.Length;
            uint lui_Increment = (uint)(1 + ((((uint)ar_Bucket.mi_HashCode >> 5) + 1) % (lui_BucketCount - 1)));

            uint lui_Walker = (uint)ar_Bucket.mi_HashCode % lui_BucketCount;
            for (;;)
            {
                int li_Index = (int)lui_Walker;
                if (ak_Buckets[li_Index].mk_Key == null)
                {
                    ak_Buckets[li_Index] = ar_Bucket;
                    return;
                }

                // since current bucket is occupied mark it as duplicate
                ak_Buckets[li_Index].mi_HashCode |= unchecked((int)0x80000000);

                lui_Walker += lui_Increment;
                lui_Walker %= lui_BucketCount;
            }
        }

        private void ExpandBucketsArray()
        {
            int li_NewSize = FindPrimeGreater(mk_Buckets.Length * 2);

            r_Bucket[] lk_Buckets = new r_Bucket[li_NewSize];
            foreach (r_Bucket lr_Bucket in mk_Buckets)
            {
                if (lr_Bucket.mk_Key == null)
                    continue;
                InternalExpandInsert(lk_Buckets, lr_Bucket);
            }

            mk_Buckets = lk_Buckets;
            mi_GrowSize = (md_LoadFactor < 1.0) ? (int)(md_LoadFactor * li_NewSize) : li_NewSize-1;
        }

        private uint ComputeHashAndStep(object ak_Key, out uint aui_Increment) 
        {
            // mask the sign bit (our collision indicator)
            uint lui_HashCode = (uint)GetHashHelper(ak_Key) & 0x7fffffff;
            // calc increment value relatively prime to mk_Buckets.Length 
            aui_Increment = (uint)(1 + (((lui_HashCode >> 5) + 1) % ((uint)mk_Buckets.Length - 1)));
            return lui_HashCode;
        }

        private int GetHashHelper(object ak_Key)
        {
            if (mk_HashProvider != null)
                return mk_HashProvider.GetHashCode(ak_Key);
            return ak_Key.GetHashCode();
        }

        private bool EqualsHelper(object ak_ObjA, object ak_ObjB)
        {
            if (mk_Comparer != null)
                return (mk_Comparer.Compare(ak_ObjA, ak_ObjB) == 0);
            return Object.Equals(ak_ObjA, ak_ObjB);
        }
    }
}