using System;
using System.Collections;
using System.Collections.Generic;
using System.Xml.Serialization;
using Top.Api.Util;

namespace Top.Api.Cluster
{
    public class Weightable
    {
        public double Weight { get; set; }
    }
    public class ApiRule : Weightable
    {
        public string Name { get; set; }
    }
    public class ApiConfig
    {
        public string User { get; set; }

        public List<ApiRule> Rules { get; set; }
    }

    public class VipRule : Weightable
    {
        public string Vip { get; set; }
    }

    public class EnvConfig
    {
        public string Domain { get; set; }

        public string Protocol { get; set; }

        public List<VipRule> VipRules { get; set; }
    }
    public class DnsConfig
    {
        public IDictionary<string, string> GlobalDict { get; set; }

        public IDictionary<string, ApiConfig> ApiDict { get; set; }

        public IDictionary<string, List<EnvConfig>> EnvDict { get; set; }

        public IDictionary<string, IDictionary<string, string>> UserDict { get; set; }

        public static DnsConfig parse(string json)
        {
            DnsConfig dnsConfig = new DnsConfig();
            IDictionary root = TopUtils.JsonToObject(json) as IDictionary;
            foreach (string configType in root.Keys)
            {
                if ("config".Equals(configType))
                {
                    dnsConfig.GlobalDict = new Dictionary<string, string>();
                    IDictionary globalInfo = root[configType] as IDictionary;
                    foreach (string key in globalInfo.Keys)
                    {
                        dnsConfig.GlobalDict[key] = globalInfo[key] as string;
                    }
                }
                else if ("env".Equals(configType))
                {
                    IDictionary envInfos = root[configType] as IDictionary;
                    dnsConfig.EnvDict = new Dictionary<string, List<EnvConfig>>();
                    foreach (string envName in envInfos.Keys)
                    {
                        IDictionary envInfo = envInfos[envName] as IDictionary;
                        List<EnvConfig> envConfigs = new List<EnvConfig>();

                        foreach (string domainName in envInfo.Keys)
                        {
                            IDictionary domainInfo = envInfo[domainName] as IDictionary;
                            EnvConfig envConfig = new EnvConfig();
                            envConfig.Domain = domainName as string;
                            envConfig.Protocol = domainInfo["proto"] as string;
                            IList vipInfos = domainInfo["vip"] as IList;
                            List<VipRule> vipRules = new List<VipRule>();
                            foreach (string vipInfo in vipInfos)
                            {
                                string[] vipInfoTmp = vipInfo.ToString().Split('|');
                                VipRule vipRule = new VipRule();
                                vipRule.Vip = vipInfoTmp[0];
                                vipRule.Weight = double.Parse(vipInfoTmp[1]);
                                vipRules.Add(vipRule);
                            }
                            envConfig.VipRules = vipRules;
                            envConfigs.Add(envConfig);
                        }

                        dnsConfig.EnvDict[envName] = envConfigs;
                    }
                }
                else if ("api".Equals(configType))
                {
                    dnsConfig.ApiDict = new Dictionary<string, ApiConfig>();
                    IDictionary apiInfos = root[configType] as IDictionary;
                    foreach (string apiName in apiInfos.Keys)
                    {
                        IDictionary apiInfo = apiInfos[apiName] as IDictionary;
                        ApiConfig apiConfig = new ApiConfig();
                        apiConfig.User = apiInfo["user"] as string;
                        List<ApiRule> apiRules = new List<ApiRule>();
                        IList apiRuleInfos = apiInfo["rule"] as IList;
                        foreach (string apiRuleInfo in apiRuleInfos)
                        {
                            string[] apiRuleInfoTmp = apiRuleInfo.ToString().Split('|');
                            ApiRule apiRule = new ApiRule();
                            apiRule.Name = apiRuleInfoTmp[0];
                            apiRule.Weight = double.Parse(apiRuleInfoTmp[1]);
                            apiRules.Add(apiRule);
                        }
                        apiConfig.Rules = apiRules;
                        dnsConfig.ApiDict[apiName] = apiConfig;
                    }
                }
                else if ("user".Equals(configType))
                {
                    dnsConfig.UserDict = new Dictionary<string, IDictionary<string, string>>();
                    IDictionary userInfos = root[configType] as IDictionary;
                    foreach (string routeName in userInfos.Keys)
                    {
                        IDictionary envInfos = userInfos[routeName] as IDictionary;
                        IDictionary<string, string> tags = new Dictionary<string, string>();
                        foreach (string envName in envInfos.Keys)
                        {
                            IList tagInfos = envInfos[envName] as IList;
                            foreach (string tagName in tagInfos)
                            {
                                tags.Add(tagName, envName);
                            }
                        }
                        dnsConfig.UserDict[routeName] = tags;
                    }
                }
            }
            return dnsConfig;
        }

        public string GetBestVipUrl(string serverUrl, string apiName, string session)
        {
            if (ApiDict.ContainsKey(apiName))
            {
                ApiConfig apiConfig = ApiDict[apiName];
                if (!string.IsNullOrEmpty(session) && apiConfig.User != null)
                {
                    string flag = GetUserFlag(session);
                    if (flag != null && UserDict.ContainsKey(apiConfig.User))
                    {
                        IDictionary<string, string> userEnvs = UserDict[apiConfig.User];
                        if (userEnvs.ContainsKey(flag))
                        {
                            string userEnv = userEnvs[flag];
                            if (EnvDict.ContainsKey(userEnv))
                            {
                                List<EnvConfig> envConfigs = EnvDict[userEnv];
                                return GetEnvVipUrl(serverUrl, envConfigs);
                            }
                        }
                    }
                }
                return GetApiVipUrl(serverUrl, apiConfig);
            }
            else
            {
                List<EnvConfig> envConfigs = EnvDict[GlobalDict["def_env"]];
                return GetEnvVipUrl(serverUrl, envConfigs);
            }
        }

        private string GetApiVipUrl(string serverUrl, ApiConfig apiConfig)
        {
            ApiRule apiRule = ClusterManager.GetElementByWeight(apiConfig.Rules);
            if (EnvDict.ContainsKey(apiRule.Name))
            {
                List<EnvConfig> envConfigs = EnvDict[apiRule.Name];
                return GetEnvVipUrl(serverUrl, envConfigs);
            }
            else
            {
                List<EnvConfig> envConfigs = EnvDict[GlobalDict["def_env"]];
                return GetEnvVipUrl(serverUrl, envConfigs);
            }
        }

        private string GetEnvVipUrl(string serverUrl, List<EnvConfig> envConfigs)
        {
            foreach (EnvConfig envConfig in envConfigs)
            {
                Uri uri = new Uri(serverUrl);
                if (uri.Host.Equals(envConfig.Domain, StringComparison.OrdinalIgnoreCase) && uri.Scheme.Equals(envConfig.Protocol, StringComparison.OrdinalIgnoreCase))
                {
                    string vip = ClusterManager.GetElementByWeight<VipRule>(envConfig.VipRules).Vip;
                    return serverUrl.Replace(envConfig.Domain, vip);
                }
            }
            return serverUrl;
        }

        private string GetUserFlag(string session)
        {
            if (!string.IsNullOrEmpty(session) && session.Length > 5)
            {
                if (session.StartsWith("6") || session.StartsWith("7"))
                {
                    return session.Substring(session.Length - 1, 1);
                }
                else if (session.StartsWith("5") || session.StartsWith("8"))
                {
                    return session.Substring(5, 1);
                }
            }
            return null;
        }

        public long GetVersion()
        {
            if (GlobalDict.ContainsKey("GlobalDict"))
            {
                return long.Parse(GlobalDict["GlobalDict"]);
            }
            else
            {
                return 0;
            }
        }

        public int GetRefreshInterval()
        {
            if (GlobalDict.ContainsKey("interval"))
            {
                return int.Parse(GlobalDict["interval"]);
            }
            else
            {
                return 30; // 默认半小时刷新一次
            }
        }

    }

    public class HttpdnsGetResponse : TopResponse
    {
        [XmlElement("result")]
        public string Result { get; set; }
    }

    public class HttpdnsGetRequest : BaseTopRequest<HttpdnsGetResponse>
    {
        public override string GetApiName()
        {
            return "taobao.httpdns.get";
        }

        public override IDictionary<string, string> GetParameters()
        {
            TopDictionary parameters = new TopDictionary();
            return parameters;
        }

        public override void Validate()
        {
        }
    }
}