using System;
#if USE_GENERICS
using System.Collections.Generic;
#endif
using System.Collections;
using Perst;

namespace Perst.Impl
{
#if USE_GENERICS
    class ThickIndex<K,V> : PersistentCollection<V>, Index<K,V> where V:class,IPersistent
#else
    class ThickIndex : PersistentCollection, Index 
#endif
    { 
#if USE_GENERICS
        private Index<K,IPersistent> index;
#else
        private Index index;
#endif
        private int   nElems;

        const int BTREE_THRESHOLD = 128;

#if USE_GENERICS
        internal ThickIndex(StorageImpl db) 
            : base(db)
        {
            index = db.CreateIndex<K,IPersistent>(true);
        }
#else
        internal ThickIndex(Type keyType, StorageImpl db) 
            : base(db)
        {
            index = db.CreateIndex(keyType, true);
        }
#endif
    
        ThickIndex() {}

        public override int Count 
        { 
            get 
            {
                return nElems;
            }
        }

#if USE_GENERICS
        public V this[K key] 
#else
        public IPersistent this[object key] 
#endif
        {
            get 
            {
                return Get(key);
            }
            set 
            {
                Set(key, value);
            }
        } 
    
#if USE_GENERICS
        public V[] this[K from, K till] 
#else
        public IPersistent[] this[object from, object till] 
#endif
        {
            get 
            {
                return Get(from, till);
            }
        }

#if USE_GENERICS
        public V Get(Key key) 
#else
        public IPersistent Get(Key key) 
#endif
        {
            IPersistent s = index.Get(key);
            if (s == null) 
            { 
                return null;
            }
#if USE_GENERICS
            Relation<V,V> r = s as Relation<V,V>;
#else
            Relation r = s as Relation;
#endif
            if (r != null)
            { 
                if (r.Count == 1) 
                { 
                    return r[0];
                }
            }
            throw new StorageError(StorageError.ErrorCode.KEY_NOT_UNIQUE);
        }
                  
#if USE_GENERICS
        public V[] Get(Key from, Key till) 
#else
        public IPersistent[] Get(Key from, Key till) 
#endif
        {
            return extend(index.Get(from, till));
        }

#if USE_GENERICS
        public V Get(K key) 
#else
        public IPersistent Get(object key) 
#endif
        {
            return Get(KeyBuilder.getKeyFromObject(key));
        }
    
#if USE_GENERICS
        public V[] Get(K from, K till) 
#else
        public IPersistent[] Get(object from, object till) 
#endif
        {
            return Get(KeyBuilder.getKeyFromObject(from), KeyBuilder.getKeyFromObject(till));
        }

#if USE_GENERICS
        private V[] extend(IPersistent[] s) 
        { 
            List<V> list = new List<V>();
            for (int i = 0; i < s.Length; i++) 
            { 
                list.AddRange((ICollection<V>)s[i]);
            }
            return list.ToArray();
        }
#else
        private IPersistent[] extend(IPersistent[] s) 
        { 
            ArrayList list = new ArrayList();
            for (int i = 0; i < s.Length; i++) 
            { 
                list.AddRange((ICollection)s[i]);
            }
            return (IPersistent[])list.ToArray(typeof(IPersistent));
        }
#endif

                      
#if USE_GENERICS
        public V[] GetPrefix(string prefix) 
#else
        public IPersistent[] GetPrefix(string prefix) 
#endif
        { 
            return extend(index.GetPrefix(prefix));
        }
    
#if USE_GENERICS
        public V[] PrefixSearch(string word) 
#else
        public IPersistent[] PrefixSearch(string word) 
#endif
        { 
            return extend(index.PrefixSearch(word));
        }
           
        public int Size() 
        { 
            return nElems;
        }
    
#if USE_GENERICS
        public override void Clear() 
#else
        public void Clear() 
#endif
        { 
            foreach (IPersistent o in this) 
            { 
                o.Deallocate();
            }
            index.Clear();
            nElems = 0;
            Modify();
        }

#if USE_GENERICS
        public V[] ToArray() 
#else
        public IPersistent[] ToArray() 
#endif
        { 
            return extend(index.ToArray());
        }
        
        public Array ToArray(Type elemType) 
        { 
            ArrayList list = new ArrayList();
            foreach (ICollection c in index) 
            { 
                list.AddRange(c);
            }
            return list.ToArray(elemType);
        }

#if USE_GENERICS
        class ExtendEnumerator : IEnumerator<V>, IEnumerable<V>, IEnumerable, PersistentEnumerator
#else
        class ExtendEnumerator : IEnumerable, PersistentEnumerator
#endif
        {  
            public void Dispose() {}

            public bool MoveNext() 
            { 
                while (!inner.MoveNext()) 
                {                 
                    if (outer.MoveNext()) 
                    {
#if USE_GENERICS
                        inner = ((IEnumerable<V>)outer.Current).GetEnumerator();
#else
                        inner = ((IEnumerable)outer.Current).GetEnumerator();
#endif
                    } 
                    else 
                    { 
                        return false;
                    }
                }
                return true;
            }

#if USE_GENERICS
            object IEnumerator.Current
            {
                get
                {
                    return inner.Current;
                }
            }

            public V Current 
#else
            public object Current 
#endif
            {
                get 
                {
                    return inner.Current;
                }
            }

            public int CurrentOid 
            {
                get 
                {
                    return ((PersistentEnumerator)inner).CurrentOid;
                }
            }

            public void Reset() 
            {
#if !USE_GENERICS
                outer.Reset();
#endif
                if (outer.MoveNext()) 
                {
#if USE_GENERICS
                    inner = ((IEnumerable<V>)outer.Current).GetEnumerator();
#else
                    inner = ((IEnumerable)outer.Current).GetEnumerator();
#endif
                }
            }

#if USE_GENERICS
            IEnumerator IEnumerable.GetEnumerator()
            {
                return this;
            }

            public IEnumerator<V> GetEnumerator() 
#else
            public IEnumerator GetEnumerator() 
#endif
            {
                return this;
            }

#if USE_GENERICS
            internal ExtendEnumerator(IEnumerator<IPersistent> enumerator) 
#else
            internal ExtendEnumerator(IEnumerator enumerator) 
#endif
            { 
                outer = enumerator;
                Reset();
            }

#if USE_GENERICS
            private IEnumerator<IPersistent> outer;
            private IEnumerator<V>           inner;
#else
            private IEnumerator outer;
            private IEnumerator inner;
#endif
        }


        class ExtendDictionaryEnumerator : IDictionaryEnumerator 
        {  
            public object Current 
            {
                get 
                {
                    return Entry;
                }
            }

            public DictionaryEntry Entry 
            {
                get 
                {
                    return new DictionaryEntry(key, inner.Current);
                }
            }

            public object Key 
            {
                get 
                {
                    return key;
                }
            }

            public object Value 
            {
                get 
                {
                    return inner.Current;
                }
            }

            public void Dispose() {}

            public bool MoveNext() 
            { 
                while (!inner.MoveNext()) 
                {                 
                    if (outer.MoveNext()) 
                    {
                        key = outer.Key;
#if USE_GENERICS
                        inner = ((IEnumerable<V>)outer.Value).GetEnumerator();
#else
                        inner = ((IEnumerable)outer.Value).GetEnumerator();
#endif
                    } 
                    else 
                    { 
                        return false;
                    }
                }
                return true;
            }

            public virtual void Reset() 
            {
#if !USE_GENERICS
                outer.Reset();
#endif
                if (outer.MoveNext()) 
                {
                    key = outer.Key;
#if USE_GENERICS
                    inner = ((IEnumerable<V>)outer.Value).GetEnumerator();
#else
                    inner = ((IEnumerable)outer.Value).GetEnumerator();
#endif
                }
            }
       
            internal ExtendDictionaryEnumerator(IDictionaryEnumerator enumerator) 
            { 
                outer = enumerator;
                Reset();
            }

            private IDictionaryEnumerator outer;
#if USE_GENERICS
            private IEnumerator<V>        inner;
#else
            private IEnumerator           inner;
#endif
            private object                key;
        }

        class ExtendDictionaryStartFromEnumerator : ExtendDictionaryEnumerator
        {  
#if USE_GENERICS
            internal ExtendDictionaryStartFromEnumerator(ThickIndex<K,V> index, int start, IterationOrder order) 
#else
            internal ExtendDictionaryStartFromEnumerator(ThickIndex index, int start, IterationOrder order) 
#endif
                : base(index.GetDictionaryEnumerator(null, null, order))
            { 
                this.index = index;
                this.start = start;
                this.order = order;
                Reset();
            }
            
            public override void Reset()
            {
                base.Reset();
                int skip = (order == IterationOrder.AscentOrder) ? start : index.Count - start - 1;
                while (--skip >= 0 && MoveNext());
            } 
                
#if USE_GENERICS
            ThickIndex<K,V> index;
#else
            ThickIndex index;
#endif
            IterationOrder order;
            int start;
        }