using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using Zm.Business;
using Zm.Common;
//using Zm.Common.Caching;
using Zm.Common.Config;
using Zm.Domain;

namespace Zm.Api.Infrastructures
{
    public class WebCache : IGlobalCache
    {
        private const int EXPIRE_MINUTES_SYSTEM_CONST_CACHE = 60;
        private const int EXPIRE_MINUTES_SYSTEM_SWITCH_CACHE = 600;
        private const int EXPIRE_MINUTES_PARA_AREA = 60;
        private const int EXPIRE_MINUTES_BUSINESS_COAL_CATE = 720;
        private const int EXPIRE_MINUTES_BUSINESS_COMPANY = 10;
        private const int EXPIRE_MINUTES_BUSINESS_MEMBER = 10;
        private const int EXPIRE_MINUTES_PARA_PARA = 60;


        private const string KEY_BUSINESS_COAL_CATE = "business_coalcate";
        private const string KEY_BUSINESS_COMPANY = "business_company";
        private const string KEY_BUSINESS_MEMBER = "business_member";

        private const string KEY_SYS_CONST = "system_const";
        private const string KEY_SYS_SWITCH = "system_switch";
        private const string KEY_PARA_AREA = "para_area";
        private const string KEY_PARA_PARA = "para_para";

        public WebCache()
        {
            Init();
        }

        private void Init()
        {
            try
            {
                CacheSystemConsts();
                CacheSystemSwitchs();
                CacheCoalCates();
                CacheBaseAreas();
                CacheParameters();
                CacheCompanyBriefs();
                CacheMemberBriefs();
            }
            catch (Exception ex)
            {
                LogHelper.Error("WebCache初始化失败", ex);
            }
        }

        public KeySaveDictionary<string, string> SystemConst
        {
            get
            {
                KeySaveDictionary<string, string> sysConst = null;

                try
                {
                    sysConst = CacheHelper.Get<KeySaveDictionary<string, string>>(KEY_SYS_CONST);
                }
                catch (Exception ex)
                {
                    LogHelper.Error("从全局缓存里面获取系统常量信息失败, exception:" + ex.ToString());
                }
                finally
                {
                    if (sysConst == null)
                    {
                        sysConst = CacheSystemConsts();
                    }
                }

                return sysConst;
            }
        }

        public KeySaveDictionary<string, string> SystemSwitch
        {
            get
            {
                KeySaveDictionary<string, string> sysSwitch = null;

                try
                {
                    sysSwitch = CacheHelper.Get<KeySaveDictionary<string, string>>(KEY_SYS_SWITCH);
                }
                catch (Exception ex)
                {
                    LogHelper.Error("从全局缓存里面获取系统开关信息失败, exception:" + ex.ToString());
                }
                finally
                {
                    if (sysSwitch == null)
                    {
                        sysSwitch = CacheSystemSwitchs();
                    }
                }

                return sysSwitch;
            }
        }

        public List<BaseArea> BaseAreas
        {
            get
            {
                List<BaseArea> areas = null;

                try
                {
                    areas = CacheHelper.Get<List<BaseArea>>(KEY_PARA_AREA);
                }
                catch (Exception ex)
                {
                    LogHelper.Error("从全局缓存里面获取地区信息失败" + ex.ToString());
                }
                finally
                {
                    if (areas == null)
                    {
                        areas = CacheBaseAreas();
                    }
                }

                return areas;
            }
        }

        public List<CoalCate> CoalCates
        {
            get
            {
                List<CoalCate> coalCates = null;

                try
                {
                    coalCates = CacheHelper.Get<List<CoalCate>>(KEY_BUSINESS_COAL_CATE);
                }
                catch (Exception ex)
                {
                    LogHelper.Error("从全局缓存里面获取煤炭类型失败" + ex.ToString());
                }
                finally
                {
                    if (coalCates == null)
                    {
                        coalCates = CacheCoalCates();
                    }
                }

                return coalCates;
            }
        }

        public List<MemberBrief> MemberBriefs
        {
            get
            {
                List<MemberBrief> members = null;

                try
                {
                    members = CacheHelper.Get<List<MemberBrief>>(KEY_BUSINESS_MEMBER);
                }
                catch (Exception ex)
                {
                    LogHelper.Error("从全局缓存里面获取会员简短信息失败" + ex.ToString());
                }
                finally
                {
                    if (members == null)
                    {
                        members = CacheMemberBriefs();
                    }
                }

                return members;
            }
        }

        public List<CompanyBrief> CompanyBriefs
        {
            get
            {
                List<CompanyBrief> companys = null;

                try
                {
                    companys = CacheHelper.Get<List<CompanyBrief>>(KEY_BUSINESS_COMPANY);
                }
                catch (Exception ex)
                {
                    LogHelper.Error("从全局缓存里面获取公司简短信息失败" + ex.ToString());
                }
                finally
                {
                    if (companys == null)
                    {
                        companys = CacheCompanyBriefs();
                    }
                }

                return companys;
            }
        }

        public List<Parameter> Parameters
        {
            get
            {
                List<Parameter> parameters = null;

                try
                {
                    parameters = CacheHelper.Get<List<Parameter>>(KEY_PARA_PARA);
                }
                catch (Exception ex)
                {
                    LogHelper.Error("从全局缓存里面获取参数信息失败" + ex.ToString());
                }
                finally
                {
                    if (parameters == null)
                    {
                        parameters = CacheParameters();
                    }
                }

                return parameters;
            }
        }

        private static KeySaveDictionary<string, string> CacheSystemConsts()
        {
            KeySaveDictionary<string, string> sysConst = new KeySaveDictionary<string, string>();

            List<Parameter> parameters = null;
            try
            {
                parameters = ParameterManager.GetParameterList(ParameterConfig.TypeKey.SystemConst);
            }
            catch (Exception ex)
            {
                LogHelper.Error("获取所有系统常量失败, exception:" + ex.ToString());
            }

            if (parameters != null)
            {
                foreach (var p in parameters)
                {
                    if (!string.IsNullOrWhiteSpace(p.Key))
                    {
                        if (string.IsNullOrWhiteSpace(p.Value1))
                        {
                            if (GlobalConfig.DEFAULT_SYSTEM_CONST.ContainsKey(p.Key))
                            {
                                sysConst[p.Key] = GlobalConfig.DEFAULT_SYSTEM_CONST[p.Key];
                            }
                        }
                        else
                        {
                            sysConst[p.Key] = p.Value1;
                        }
                    }
                }
            }

            foreach (var item in GlobalConfig.DEFAULT_SYSTEM_CONST)
            {
                if (!sysConst.ContainsKey(item.Key))
                {
                    sysConst[item.Key] = item.Value;
                }
            }


            CacheObject(KEY_SYS_CONST, sysConst, EXPIRE_MINUTES_SYSTEM_SWITCH_CACHE);

            return sysConst;
        }

        private static KeySaveDictionary<string, string> CacheSystemSwitchs()
        {
            KeySaveDictionary<string, string> sysSwitch = new KeySaveDictionary<string, string>();

            List<Parameter> parameters = null;
            try
            {
                parameters = ParameterManager.GetParameterList(ParameterConfig.TypeKey.SystemSwitch);
            }
            catch (Exception ex)
            {
                LogHelper.Error("获取所有系统开关量失败, exception:" + ex.ToString());
            }

            if (parameters != null && parameters.Count != 0)
            {
                foreach (var p in parameters)
                {
                    if (!string.IsNullOrWhiteSpace(p.Key))
                    {
                        if (string.IsNullOrWhiteSpace(p.Value1))
                        {
                            if (GlobalConfig.DEFAULT_SYSTEM_SWITCH.ContainsKey(p.Key))
                            {
                                sysSwitch[p.Key] = GlobalConfig.DEFAULT_SYSTEM_SWITCH[p.Key];
                            }
                        }
                        else
                        {
                            sysSwitch[p.Key] = p.Value1;
                        }
                    }
                }
            }

            foreach (var item in GlobalConfig.DEFAULT_SYSTEM_SWITCH)
            {
                if (!sysSwitch.ContainsKey(item.Key))
                {
                    sysSwitch[item.Key] = item.Value;
                }
            }


            CacheObject(KEY_SYS_SWITCH, sysSwitch, EXPIRE_MINUTES_SYSTEM_SWITCH_CACHE);

            return sysSwitch;
        }

        private static List<BaseArea> CacheBaseAreas()
        {
            List<BaseArea> areas = null;
            try
            {
                areas = ParameterManager.GetBaseAreaList();
            }
            catch (Exception ex)
            {
                LogHelper.Error("从memcached获取地区信息失败" + ex.ToString());
            }

            if (areas != null && areas.Count != 0)
            {
                CacheObject(KEY_PARA_AREA, areas, EXPIRE_MINUTES_PARA_AREA);
            }

            return areas;
        }

        private static List<CoalCate> CacheCoalCates()
        {
            List<CoalCate> coalCates = null;
            try
            {
                coalCates = ParameterManager.GetAllCoalCateList();
            }
            catch (Exception ex)
            {
                LogHelper.Error("从memcached获取煤炭类型信息失败" + ex.ToString());
            }

            if (coalCates != null && coalCates.Count != 0)
            {
                CacheObject(KEY_BUSINESS_COAL_CATE, coalCates, EXPIRE_MINUTES_BUSINESS_COAL_CATE);
            }

            return coalCates;
        }

        private static List<Parameter> CacheParameters()
        {
            List<Parameter> parameters = null;
            try
            {
                parameters = ParameterManager.GetAllParameterList();
            }
            catch (Exception ex)
            {
                LogHelper.Error("从memcached获取参数信息失败" + ex.ToString());
            }

            if (parameters != null && parameters.Count != 0)
            {
                CacheObject(KEY_PARA_PARA, parameters, EXPIRE_MINUTES_PARA_PARA);
            }

            return parameters;
        }

        private static List<CompanyBrief> CacheCompanyBriefs()
        {
            List<CompanyBrief> companys = null;
            try
            {
                companys = ParameterManager.GetAllCompanyBriefList();
            }
            catch (Exception ex)
            {
                LogHelper.Error("从memcached获取公司简短信息失败" + ex.ToString());
            }

            if (companys != null && companys.Count != 0)
            {
                CacheObject(KEY_BUSINESS_COMPANY, companys, EXPIRE_MINUTES_BUSINESS_COMPANY);
            }

            return companys;
        }

        private static List<MemberBrief> CacheMemberBriefs()
        {
            List<MemberBrief> members = null;
            try
            {
                members = ParameterManager.GetAllMemberBriefList();
            }
            catch (Exception ex)
            {
                LogHelper.Error("从memcached获取会员简短信息失败" + ex.ToString());
            }

            if (members != null && members.Count != 0)
            {
                CacheObject(KEY_BUSINESS_MEMBER, members, EXPIRE_MINUTES_BUSINESS_MEMBER);
            }

            return members;
        }

        private static void CacheObject(string key, object data, int expires)
        {
            try
            {
                CacheHelper.Insert(key, data, expires);
            }
            catch (Exception ex)
            {
                LogHelper.Error("将数据插入web cache失败, exception:" + ex.ToString());
            }
        }
    }
}