using System;
using System.Collections.Generic;

using System.Text;

namespace Thousandto.Core.Base
{

    public interface IGcSweepingStrategy
    {
        bool Sweepable();
        bool Sweepable(object value);
    }

    public interface IGcGenerationStrategy
    {
        int GetMaxGenerationCount();
        bool NextGeneration(int gen, int lived);
        bool Collectable(int gen, int last);
    }

    public class GcGenerationStrategy : IGcGenerationStrategy
    {
        public const int MAX_GENERATION_INDEX = 32;
        public static int Now()
        {
            return System.Environment.TickCount;
        }
        public int GetMaxGenerationCount()
        {
            return MAX_GENERATION_INDEX;
        }
        public bool NextGeneration(int gen, int lived)
        {
            return lived > 60000 * gen;
        }
        public bool Collectable(int gen, int last)
        {
            return Now() - last > 60000 * gen;
        }
        public static GcGenerationStrategy sharedInstance = new GcGenerationStrategy();
    }

    public class GcSweepingStrategy : IGcSweepingStrategy
    {
        int _past = 0;
        int _interval = 0;
        internal const int DefaultInterval = 8000; //8s
        public GcSweepingStrategy(int intervalMS = 0)
        {
            if (intervalMS <= 0)
            {
                intervalMS = DefaultInterval;
            }
            _interval = intervalMS;
            _past = System.Environment.TickCount;
        }
        public virtual bool Sweepable(object value)
        {
            return true;
        }
        public virtual bool Sweepable()
        {
            bool result = false;
            int now = System.Environment.TickCount;
            if (now - _past > _interval)
            {
                result = true;
                _past = now;
            }
            return result;
        }
    }

    public enum DataCacheCollectableFlag
    {
        None = 0,
        No = 1,
        Yes = 2,
        Collectable = 4,
        Touching = 8,
    }

    public class DataCache<TKey, TValue>
    {
        class Item
        {
            internal TValue value = default(TValue);
            internal int lastTouchedTime = 0;
            internal int livedTime = 0;
            internal int generation = 0;
            internal bool immortal = false;
            internal DataCache<TKey, TValue> owner;

            internal void Assign(TValue source, int gen = 1, int now = 0)
            {
                if (now <= 0)
                {
                    now = GcGenerationStrategy.Now();
                }
                value = source;
                generation = gen;
                lastTouchedTime = now;
                livedTime = 0;
            }
            internal void Touch()
            {
                var n = GcGenerationStrategy.Now();
                var e = n - lastTouchedTime;
                lastTouchedTime = n;
                livedTime += e;
                if (owner._gen.NextGeneration(generation, livedTime) && generation + 1 <= owner._gen.GetMaxGenerationCount())
                {
                    ++generation;
                }
            }
            internal Item(TValue source, DataCache<TKey, TValue> _owner)
            {
                owner = _owner;
                Assign(source, 1, GcGenerationStrategy.Now());
            }
            internal bool Collectable()
            {
                return immortal == false && owner._gen.Collectable(generation, lastTouchedTime);
            }
        }

        IGcSweepingStrategy _sweeper = null;
        IGcGenerationStrategy _gen = null;
        MyAction<TValue> _releaseValueFunc = null;
        MyFunc<TValue, DataCacheCollectableFlag> _collectableFunc = null;
        Dictionary<TKey, Item> _tank = null;

        Dictionary<TKey, Item> tank
        {
            get
            {
                if (_tank == null)
                {
                    _tank = new Dictionary<TKey, Item>();
                }
                return _tank;
            }
        }

        public DataCache(int sweepIntervalMS = -1,
            IGcSweepingStrategy sweeper = null,
            IGcGenerationStrategy gen = null,
            MyAction<TValue> valueReleaser = null,
            MyFunc<TValue, DataCacheCollectableFlag> collectableFunc = null)
        {
            _sweeper = sweeper;
            _releaseValueFunc = valueReleaser;
            _collectableFunc = collectableFunc;
            if (_sweeper == null)
            {
                if (sweepIntervalMS < 0)
                {
                    sweepIntervalMS = GcSweepingStrategy.DefaultInterval;
                }
                _sweeper = new GcSweepingStrategy(sweepIntervalMS);
            }
            _gen = gen ?? GcGenerationStrategy.sharedInstance;
        }

        ~DataCache()
        {
            Clear();
        }

        Item GetItem(TKey key)
        {
            Item item = null;
            if (_tank != null && _tank.TryGetValue(key, out item))
            {
                item.Touch();
                return item;
            }
            else
            {
                return null;
            }
        }

        void _ReleaseValue(TValue value)
        {
            if (_releaseValueFunc != null)
            {
                _releaseValueFunc(value);
                value = default(TValue);
            }
        }

        int _DoSweep(bool force)
        {
            int result = 0;
            if (_tank != null)
            {
                List<TKey> _removeList = null;
                var e = _tank.GetEnumerator();
                try
                {
                    while (e.MoveNext())
                    {
                        var item = e.Current;
                        if (force)
                        {
                            item.Value.immortal = false;
                        }
                        if (item.Value.Collectable())
                        {
                            if (_collectableFunc != null)
                            {
                                var ret = _collectableFunc(item.Value.value);
                                if (ret != DataCacheCollectableFlag.None)
                                {
                                    if ((ret & DataCacheCollectableFlag.No) != 0)
                                    {
                                        if ((ret & DataCacheCollectableFlag.Touching) != 0)
                                        {
                                            item.Value.Touch();
                                        }
                                        continue;
                                    }
                                }
                            }
                            if (_removeList == null)
                            {
                                _removeList = new List<TKey>();
                            }
                            _ReleaseValue(item.Value.value);
                            _removeList.Add(item.Key);
                        }
                    }
                }
                finally
                {
                    e.Dispose();
                }

                if (_removeList != null)
                {
                    for (int i = 0; i < _removeList.Count; ++i)
                    {
                        if (_tank.Remove(_removeList[i]))
                        {
                            result += 1;
                        }
                    }
                }
            }
            return result;
        }

        public bool SetImmortal(TKey key, bool enable = true)
        {
            var item = GetItem(key);
            if (item != null)
            {
                item.immortal = enable;
                return true;
            }
            return false;
        }

        public TValue Get(TKey key, bool sweep = true)
        {
            var item = GetItem(key);
            var ret = item != null ? item.value : default(TValue);
            if (sweep)
            {
                Sweep();
            }
            return ret;
        }

        public bool Remove(TKey key)
        {
            Item item = null;
            if (_tank != null && _tank.TryGetValue(key, out item))
            {
                if (_releaseValueFunc != null)
                {
                    _releaseValueFunc(item.value);
                }
                return _tank.Remove(key);
            }
            return false;
        }

        public bool Add(TKey key, TValue value)
        {
            if (value == null)
            {
                return false;
            }
            var dict = tank;
            Item item = null;
            if (dict.TryGetValue(key, out item))
            {
                item.Touch();
                return false;
            }
            item = new Item(value, this);
            dict.Add(key, item);
            return true;
        }

        public bool TryGetValue(TKey key, out TValue value, bool sweep = true)
        {
            if (_tank != null)
            {
                Item item = null;
                if (_tank.TryGetValue(key, out item))
                {
                    item.Touch();
                    value = item.value;
                    if (sweep)
                    {
                        Sweep();
                    }
                    return true;
                }
            }
            value = default(TValue);
            return false;
        }

        public void Clear()
        {
            if (_tank != null)
            {
                if (_releaseValueFunc != null)
                {
                    var e = _tank.GetEnumerator();
                    try
                    {
                        while (e.MoveNext())
                        {
                            _releaseValueFunc(e.Current.Value.value);
                        }
                    }
                    finally
                    {
                        e.Dispose();
                    }                   
                }
                _tank.Clear();
                _tank = null;
            }
        }

        public int Count
        {
            get
            {
                if (_tank != null)
                {
                    return _tank.Count;
                }
                return 0;
            }
        }

        public int ForEachValue(MyAction<TValue> func)
        {
            int count = 0;
            if (_tank != null)
            {
                var e = _tank.GetEnumerator();
                try
                {
                    while (e.MoveNext())
                    {
                        func(e.Current.Value.value);
                        ++count;
                    }
                }
                finally
                {
                    e.Dispose();
                }         
             
            }
            return count;
        }

        public int ForEach<TCtx>(MyAction<TKey, TValue, TCtx> func, TCtx ctx = null) where TCtx : class
        {
            int count = 0;
            if (_tank != null)
            {
                var e = _tank.GetEnumerator();
                try
                {
                    while (e.MoveNext())
                    {
                        func(e.Current.Key, e.Current.Value.value, ctx);
                        ++count;
                    }
                }
                finally
                {
                    e.Dispose();
                }         
               
            }
            return count;
        }

        public int Clear(MyFunc<int, int, int, bool> func)
        {
            int result = 0;
            if (_tank != null)
            {
                List<TKey> _removeList = null;
                var e = _tank.GetEnumerator();
                try
                {
                    while (e.MoveNext())
                    {
                        var item = e.Current;
                        bool skip = func(item.Value.generation, item.Value.lastTouchedTime, item.Value.livedTime);
                        if (!skip)
                        {
                            if (_removeList == null)
                            {
                                _removeList = new List<TKey>();
                            }
                            _ReleaseValue(item.Value.value);
                            _removeList.Add(item.Key);
                        }
                    }
                }
                finally
                {
                    e.Dispose();
                }         
                
                if (_removeList != null)
                {
                    for (int i = 0; i < _removeList.Count; ++i)
                    {
                        if (_tank.Remove(_removeList[i]))
                        {
                            result += 1;
                        }
                    }
                }
            }
            return result;
        }

        public int Sweep(bool force = false)
        {
            int result = 0;
            if (force || _sweeper.Sweepable())
            {
                result = _DoSweep(force);
            }
            return result;
        }
    }

    public class DataCacheLit<TKey, TValue> : DataCache<TKey, object>
    {
        public bool Add(TKey key, TValue value)
        {
            return base.Add(key, value);
        }
        public bool TryGetValue(TKey key, out TValue value, bool sweep = true)
        {
            object _value = null;
            value = default(TValue);
            var r = base.TryGetValue(key, out _value, sweep);
            if (r)
            {
                try
                {
                    value = (TValue)_value;
                }
                catch (Exception e)
                {
                    System.Diagnostics.Trace.Fail(e.Message,e.StackTrace);
                }
            }
            return r;
        }
    }
}