using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Web;
using System.Linq.Expressions;
using Bowin.Common.Utility;
using EMIS.Entities;
using Bowin.Common.Cache;
using EMIS.ViewModel;

namespace EMIS.ViewModel.Cache
{
    public static class IdNameExt
    {
        public static string GetName(DictionaryItem dictionaryItem, int? value)
        {
            return GetDictionaryItem(dictionaryItem).Where(w => w.Value == value).Select(s => s.Name).FirstOrDefault();
        }

        public static List<Sys_DictionaryItem> GetDictionaryItem(DictionaryItem dictionaryItem)
        {
            var dictionaryCode = dictionaryItem.ToString();

            return GetDictionaryItem(dictionaryCode);
        }

        public static List<Sys_DictionaryItem> GetDictionaryItem(string dictionaryCode)
        {
            var key = "Dictionary_" + dictionaryCode;
            var cachedValue = CacheHelper.Get(key);
            if (cachedValue == null)
            {
                using (var context = new EMISNewContext())
                {
                    var result = context.Set<Sys_DictionaryItem>()
                        .Where(x => x.DictionaryCode == dictionaryCode)
                        .OrderBy(x => x.OrderNo).ThenBy(x => x.Value)
                        .AsNoTracking()
                        .ToList();

                    if (result != null)
                    {
                        CacheHelper.Add(key, result);
                        return result;
                    }
                    else
                    {
                        return null;
                    }
                }
            }
            else
            {
                return (List<Sys_DictionaryItem>)cachedValue;
            }
        }
        /// <summary>
        /// 判断是否存在字典项中
        /// </summary>
        /// <param name="dictionaryCode">字典编码</param>
        /// <returns name="dictionaryStr">判断的文字</returns>
        public static bool IsDictionaryExist(string dictionaryCode, string dictionaryStr)
        {
            return IdNameExt.GetDictionaryItem(dictionaryCode)
                         .Any(x => x.Name == dictionaryStr.Trim());
        }

        private static string ObjToName<T>(object objId, Func<T, string> func)
        {
            if (!(objId is int))
            {
                if ((objId == null || default(T).Equals(objId))) return "";
            }

            T id;
            if (objId.ToString().TryParseTo<T>(out id))
            {
                return func(id);
            }
            else
            {
                return "";
            }
        }


        private static string GetCachedValue<CT, T, TPK, TResult>(string keyTemplate,
            TPK key,
            Expression<Func<T, TPK>> pkselector,
            Expression<Func<T, TResult>> selector)
            where T : class
            where CT : DbContext, new()
        {
            if (!(key is int))
            {
                if (key == null || default(TPK).Equals(key)) return "";
            }

            var cachedValue = CacheHelper.Get(string.Format(keyTemplate, key));
            if (cachedValue == null)
            {
                ConstantExpression keyValueExp = Expression.Constant(key, pkselector.Body.Type);
                //ParameterExpression param = Expression.Parameter(predicate.Parameters[0].Type);
                Expression<Func<T, bool>> lambda =
                Expression.Lambda<Func<T, bool>>(Expression.Equal(pkselector.Body, keyValueExp), pkselector.Parameters[0]);

                using (var context = new CT())
                {
                    TResult result = context.Set<T>().Where(lambda).Select(selector).FirstOrDefault();
                    if (result != null)
                    {
                        CacheHelper.Add(string.Format(keyTemplate, key), result.ToString());
                        return result.ToString();
                    }
                    else
                    {
                        return "";
                    }
                }

            }
            else
            {
                return cachedValue.ToString();
            }
        }
        private static string GetCachedValue<T, TPK, TResult>(string keyTemplate,
            TPK key,
            Expression<Func<T, TPK>> pkselector,
            Expression<Func<T, TResult>> selector) where T : class
        {
            if (key == null) return "";
            if (default(TPK) == null)
            {
                if (key == null) return "";
            }
            else if (default(TPK).Equals(key))
            {
                return "";
            }
            var cachedValue = CacheHelper.Get(string.Format(keyTemplate, key));
            if (cachedValue == null)
            {
                ConstantExpression keyValueExp = Expression.Constant(key, pkselector.Body.Type);
                //ParameterExpression param = Expression.Parameter(predicate.Parameters[0].Type);
                Expression<Func<T, bool>> lambda =
                Expression.Lambda<Func<T, bool>>(Expression.Equal(pkselector.Body, keyValueExp), pkselector.Parameters[0]);

                using (var context = new EMISNewContext())
                {
                    TResult result = context.Set<T>().Where(lambda).Select(selector).FirstOrDefault();
                    if (result != null)
                    {
                        CacheHelper.Add(string.Format(keyTemplate, key), result.ToString());
                        return result.ToString();
                    }
                    else
                    {
                        return "";
                    }
                }

            }
            else
            {
                return cachedValue.ToString();
            }

        }
    }
}