using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Threading;
using NewLife.Collections;
using NewLife.Log;
using NewLife.Threading;

namespace XCode.Cache
{
    /// <summary>实体缓存</summary>
    /// <remarks>
    /// 第一次读取缓存的时候，同步从数据库读取，这样子手上有一份数据。
    /// 以后更新，都开异步线程去读取，而当前马上返回，让大家继续用着旧数据，这么做性能非常好。
    /// </remarks>
    /// <typeparam name="TEntity">实体类型</typeparam>
    [DisplayName("实体缓存")]
    public class EntityCache<TEntity> : CacheBase<TEntity>, IEntityCache where TEntity : Entity<TEntity>, new()
    {
        #region 基础属性
        /// <summary>缓存过期时间</summary>
        DateTime ExpiredTime { get; set; } = DateTime.Now.AddHours(-1);

        private volatile Int32 _Times;
        /// <summary>缓存更新次数</summary>
        public Int32 Times => _Times;

        /// <summary>过期时间。单位是秒，默认60秒</summary>
        public Int32 Expire { get; set; }

        /// <summary>填充数据的方法</summary>
        public Func<IList<TEntity>> FillListMethod { get; set; } = Entity<TEntity>.FindAll;

        /// <summary>是否等待第一次查询。如果不等待，第一次返回空集合。默认true</summary>
        public Boolean WaitFirst { get; set; } = true;

        /// <summary>是否在使用缓存，在不触发缓存动作的情况下检查是否有使用缓存</summary>
        internal Boolean Using { get; set; }
        #endregion

        #region 构造
        /// <summary>实例化实体缓存</summary>
        public EntityCache()
        {
            var exp = Setting.Current.EntityCacheExpire;
            if (exp <= 0) exp = 60;

            Expire = exp;
        }
        #endregion

        #region 缓存核心
        private TEntity[] _Entities = new TEntity[0];
        /// <summary>实体集合。无数据返回空集合而不是null</summary>
        public IList<TEntity> Entities
        {
            get
            {
                CheckCache();

                return _Entities;
            }
        }

        void CheckCache()
        {
            // 更新统计信息
            CheckShowStatics(ref Total, ShowStatics);

            var sec = (TimerX.Now - ExpiredTime).TotalSeconds;
            if (sec < 0)
            {
                Interlocked.Increment(ref Success);
                return;
            }

            /*
             * 来到这里，都是缓存超时的线程
             * 1，第一次请求，还没有缓存数据，需要等待首次数据
             *      WaitFirst   加锁等待
             *      !WaitFirst  跳过等待
             * 2，缓存过期，开个异步更新，继续走
             */

            if (_Times == 0)
            {
                if (WaitFirst)
                {
                    lock (this)
                    {
                        if (_Times == 0) UpdateCache("第一次");
                    }
                }
                else
                {
                    if (Monitor.TryEnter(this, 5000))
                    {
                        try
                        {
                            if (_Times == 0) UpdateCache("第一次");
                        }
                        finally
                        {
                            Monitor.Exit(this);
                        }
                    }
                }
            }
            else
                UpdateCacheAsync("过期{0:n0}秒".F(sec));

            // 只要访问了实体缓存数据集合，就认为是使用了实体缓存，允许更新缓存数据期间向缓存集合添删数据
            Using = true;
        }

        /// <summary>检索与指定谓词定义的条件匹配的所有元素。</summary>
        /// <param name="match">条件</param>
        /// <returns></returns>
        public TEntity Find(Predicate<TEntity> match)
        {
            var list = Entities;
            if (list is List<TEntity> list2) return list2.Find(match);

            return list.FirstOrDefault(e => match(e));
        }

        /// <summary>检索与指定谓词定义的条件匹配的所有元素。</summary>
        /// <param name="match">条件</param>
        /// <returns></returns>
        public IList<TEntity> FindAll(Predicate<TEntity> match)
        {
            var list = Entities;
            if (list is List<TEntity> list2) return list2.FindAll(match);

            return list.Where(e => match(e)).ToList();
        }
        #endregion

        #region 缓存操作
        private volatile Int32 _updating;

        void UpdateCacheAsync(String reason)
        {
            // 控制只有一个线程能更新
            if (Interlocked.CompareExchange(ref _updating, 1, 0) != 0) return;

            ThreadPoolX.QueueUserWorkItem(UpdateCache, reason);
        }

        void UpdateCache(String reason)
        {
            Interlocked.Increment(ref _updating);

            var ts = _Times;

            // 这里直接计算有效期，避免每次判断缓存有效期时进行的时间相加而带来的性能损耗
            // 设置时间放在获取缓存之前，让其它线程不要空等
            if (ts > 0) ExpiredTime = TimerX.Now.AddSeconds(Expire);

            WriteLog("更新{0}（第{2}次） 原因：{1}", ToString(), reason, ts + 1);

            try
            {
                _Entities = Invoke<Object, IList<TEntity>>(s => FillListMethod(), null).ToArray();
            }
            catch (Exception ex)
            {
                XTrace.WriteLine($"[{TableName}/{ConnName}]" + ex.GetTrue());
            }
            finally
            {
                _updating = 0;
            }

            ts = Interlocked.Increment(ref _Times);
            ExpiredTime = TimerX.Now.AddSeconds(Expire);
            WriteLog("完成{0}[{1}]（第{2}次）", ToString(), _Entities.Length, ts);
        }

        /// <summary>清除缓存</summary>
        public void Clear(String reason)
        {
            if (!Using) return;

            // 直接执行异步更新，明明白白，确保任何情况下数据最新，并且不影响其它任务的性能
            UpdateCacheAsync(reason);
        }

        private IEntityFactory Operate = Entity<TEntity>.Meta.Factory;
        /// <summary>添加对象到缓存</summary>
        /// <param name="entity"></param>
        public void Add(TEntity entity)
        {
            if (!Using) return;

            var es = _Entities;
            lock (es)
            {
                //es.Add(entity);

                var list = _Entities.ToList();
                list.Add(entity);
                _Entities = list.ToArray();
            }
        }

        /// <summary>从缓存中删除对象</summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public TEntity Remove(TEntity entity)
        {
            if (!Using) return null;

            var es = _Entities;

            var e = es.Find(x => x == entity);
            if (e == null)
            {
                var fi = Operate.Unique;
                if (fi != null)
                {
                    var v = entity[fi.Name];
                    e = es.Find(x => Equals(x[fi.Name], v));
                }
            }
            if (e == null) return null;

            //if (e != entity) e.CopyFrom(entity);
            // 更新实体缓存时，不做拷贝，避免产生脏数据，如果恰巧又使用单对象缓存，那会导致自动保存
            lock (es)
            {
                //es.Remove(e);

                var list = _Entities.ToList();
                list.Remove(e);
                _Entities = list.ToArray();
            }

            return e;
        }

        internal TEntity Update(TEntity entity)
        {
            if (!Using) return null;

            var es = _Entities;

            // 如果对象本身就在缓存里面，啥也不用做
            var e = es.FirstOrDefault(x => x == entity);
            if (e != null) return e;

            var idx = -1;
            var fi = Operate.Unique;
            if (fi != null)
            {
                var v = entity[fi.Name];
                idx = Array.FindIndex(es, x => Equals(x[fi.Name], v));
            }

            //if (e != entity) e.CopyFrom(entity);
            // 更新实体缓存时，不做拷贝，避免产生脏数据，如果恰巧又使用单对象缓存，那会导致自动保存
            if (idx >= 0)
                es[idx] = entity;
            else
            {
                lock (es)
                {
                    //es.Add(entity);

                    var list = _Entities.ToList();
                    list.Add(entity);
                    _Entities = list.ToArray();
                }
            }

            return e;
        }
        #endregion

        #region 统计
        /// <summary>总次数</summary>
        public Int32 Total;

        /// <summary>命中</summary>
        public Int32 Success;

        /// <summary>显示统计信息</summary>
        public void ShowStatics()
        {
            if (Total > 0)
            {
                var sb = Pool.StringBuilder.Get();
                var type = GetType();
                var name = "{2}<{0}>({1:n0})".F(typeof(TEntity).Name, _Entities.Length, type.GetDisplayName() ?? type.Name);
                sb.AppendFormat("{0,-24}", name);
                sb.AppendFormat("总次数{0,11:n0}", Total);
                if (Success > 0) sb.AppendFormat("，命中{0,11:n0}（{1,6:P02}）", Success, (Double)Success / Total);
                sb.AppendFormat("\t[{0}]", typeof(TEntity).FullName);

                XTrace.WriteLine(sb.Put(true));
            }
        }
        #endregion

        #region IEntityCache 成员
        IList<IEntity> IEntityCache.Entities { get { return new List<IEntity>(Entities); } }
        #endregion

        #region 辅助
        internal EntityCache<TEntity> CopySettingFrom(EntityCache<TEntity> ec)
        {
            Expire = ec.Expire;
            FillListMethod = ec.FillListMethod;

            return this;
        }

        /// <summary>输出名称</summary>
        /// <returns></returns>
        public override String ToString()
        {
            var type = GetType();
            return "{0}<{1}>".F(type.GetDisplayName() ?? type.Name, typeof(TEntity).Name);
        }
        #endregion
    }
}