using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Security.Cryptography;
using System.Text;

using UnityEngine;
using System.Threading;

[XLua.LuaCallCSharp]
public class Config : Singleton<Config>
{

    bool isPlaying = true;

    bool m_Inited = false;
    public bool inited {
        get { return m_Inited; }
        private set { m_Inited = value; }
    }

    Dictionary<int, Dictionary<string, ConfigBase>> configDictionary = new Dictionary<int, Dictionary<string, ConfigBase>>();

    public void RegisterGlobalEvent()
    {
        SnxxzGame.Instance.RemoveApplicationOutAction(OnApplicationOut);
        SnxxzGame.Instance.AddApplicationOutAction(OnApplicationOut);
    }

    public void LoadPriorBundleConfig()
    {
        StartSyncTask<PriorBundleConfig>();
    }

    public void PreLoadConfigs()
    {
        StartSyncTask<ApkUpdateUrlConfig>();
        StartSyncTask<PriorBundleConfig>();
        StartSyncTask<PriorLanguageConfig>();
        StartSyncTask<ContactConfig>();
        StartSyncTask<HelpInfoConfig>();
    }

    List<ConfigTask> configTasks = new List<ConfigTask>();

    public IEnumerator Co_LoadConfigs()
    {
        StartSyncTask<LoginSeverListConfig>();
        StartSyncTask<IconConfig>();
        AddAsyncTask<ItemConfig>();
        AddAsyncTask<SkillConfig>();
        AddAsyncTask<DirtyNameConfig>();
        AddAsyncTask<TASKINFOConfig>();
        AddAsyncTask<mapnpcConfig>();
        AddAsyncTask<LanguageConfig>();

        AddAsyncTask<DienstgradConfig>();
        AddAsyncTask<PlayerPropertyConfig>();
        AddAsyncTask<RealmConfig>();
        AddAsyncTask<ItemCompoundConfig>();
        AddAsyncTask<FuncConfigConfig>();
        AddAsyncTask<GodWeaponConfig>();
        AddAsyncTask<FuncOpenLVConfig>();
        AddAsyncTask<RichTextMsgReplaceConfig>();
        AddAsyncTask<SysInfoConfig>();
        AddAsyncTask<ItemPlusConfig>();
        AddAsyncTask<ItemPlusMaxConfig>();
        AddAsyncTask<PyTaskConfig>();
        AddAsyncTask<MailConfig>();
        AddAsyncTask<RuneTowerConfig>();
        AddAsyncTask<EquipWashConfig>();
        AddAsyncTask<EquipWashSpecConfig>();
        AddAsyncTask<AttrFruitConfig>();
        AddAsyncTask<RuneConfig>();
        AddAsyncTask<MapConfig>();
        AddAsyncTask<PlayerLVConfig>();
        AddAsyncTask<PetEatEquipConfig>();
        AddAsyncTask<PetInfoConfig>();
        AddAsyncTask<RandomNameConfig>();
        AddAsyncTask<PetClassCostConfig>();
        AddAsyncTask<NPCConfig>();
        AddAsyncTask<KickOutReasonConfig>();//检查断线原因
        AddAsyncTask<HorseConfig>();
        AddAsyncTask<HorseUpConfig>();
        AddAsyncTask<RankListConfig>();
        AddAsyncTask<OccupationNameConfig>();
        AddAsyncTask<EquipSuitAttrConfig>(); //装备套装属性
        AddAsyncTask<EquipSuitCompoundConfig>(); //装备套装锻造需要材料
        AddAsyncTask<DirtyWordConfig>();
        AddAsyncTask<EffectConfig>();
        AddAsyncTask<WingRefineAttrConfig>();
        AddAsyncTask<FamilyTechConfig>();
        AddAsyncTask<FamilyConfig>();
        AddAsyncTask<CreateRoleConfig>();
        AddAsyncTask<DamageNumConfig>();
        AddAsyncTask<DungeonConfig>();
        AddAsyncTask<JobSetupConfig>();
        AddAsyncTask<ModelResConfig>();
        AddAsyncTask<DailyQuestConfig>();
        AddAsyncTask<FaceConfig>();
        AddAsyncTask<DailyLivenessRewardConfig>();
        AddAsyncTask<JobNameConfig>();
        AddAsyncTask<MarketConfig>();
        AddAsyncTask<maptransportConfig>();
        AddAsyncTask<ItemPlusSumAttrConfig>();
        AddAsyncTask<RoleEquipStarsConfig>();
        AddAsyncTask<MonsterNameColorConfig>();
        AddAsyncTask<TreasureConfig>();
        AddAsyncTask<SuccessConfig>();
        AddAsyncTask<TreasureSkillConfig>();
        AddAsyncTask<mapAreaConfig>();
        AddAsyncTask<EquipDeComposeConfig>();
        AddAsyncTask<WindowSearchConfig>();
        AddAsyncTask<SignInConfig>();
        AddAsyncTask<ContinueSignInConfig>();
        AddAsyncTask<DungeonHintConfig>();
        AddAsyncTask<MapEventPointConfig>();
        AddAsyncTask<VIPAwardConfig>();
        AddAsyncTask<VipPrivilegeConfig>();
        AddAsyncTask<DailyQuestOpenTimeConfig>();
        AddAsyncTask<DungeonOpenTimeConfig>();
        AddAsyncTask<AppointItemConfig>();
        AddAsyncTask<EquipGSParamConfig>();
        AddAsyncTask<StoreConfig>();
        AddAsyncTask<WorldBossConfig>();
        AddAsyncTask<BossHomeConfig>();
        AddAsyncTask<PersonalBossConfig>();
        AddAsyncTask<ElderGodAreaConfig>();
        AddAsyncTask<RuneTowerFloorConfig>();
        AddAsyncTask<TreasureRefineConfig>();
        AddAsyncTask<AlchemyConfig>();
        AddAsyncTask<AlchemySpecConfig>();
        AddAsyncTask<QuestionBankConfig>();
        AddAsyncTask<WingRefineExpConfig>();
        AddAsyncTask<UnionLivenConfig>();
        AddAsyncTask<FunctionForecastConfig>();
        AddAsyncTask<GmCmdConfig>();
        AddAsyncTask<GetItemWaysConfig>();
        AddAsyncTask<GuideConfig>();
        AddAsyncTask<ViewRoleFuncConfig>();
        AddAsyncTask<RoleStrongerConfig>();
        AddAsyncTask<RoleResourceConfig>();
        AddAsyncTask<AudioConfig>();
        AddAsyncTask<AreaCameraConfig>();
        AddAsyncTask<NPCDialogueConfig>();
        AddAsyncTask<TaskListConfig>();
        AddAsyncTask<DemonJarConfig>();
        AddAsyncTask<StoryMissionsConfig>();
        AddAsyncTask<DungeonStateTimeConfig>();
        AddAsyncTask<DungeonInspireConfig>();
        AddAsyncTask<RuneComposeConfig>();
        AddAsyncTask<BossInfoConfig>();
        AddAsyncTask<DialogConfig>();
        AddAsyncTask<SceneShadowConfig>();
        AddAsyncTask<ResourcesBackConfig>();
        AddAsyncTask<WeatherConfig>();
        AddAsyncTask<RuleConfig>();
        AddAsyncTask<MonsterRefreshPointConfig>();
        AddAsyncTask<DogzConfig>();
        AddAsyncTask<ChestsConfig>();
        AddAsyncTask<ChestsAwardConfig>();
        AddAsyncTask<NPCDropItemConfig>();
        AddAsyncTask<TeamTargetConfig>();
        AddAsyncTask<OSCBillRankAwardConfig>();
        AddAsyncTask<OSCBillTagAwardConfig>();
        AddAsyncTask<InSevenDaysConfig>();
        AddAsyncTask<OnlineAwardConfig>();
        AddAsyncTask<LVAawrdConfig>();
        AddAsyncTask<DemonRecommondPropertyConfig>();
        AddAsyncTask<InvestConfig>();
        AddAsyncTask<SuitEffectConfig>();
        AddAsyncTask<RefineStoveConfig>();
        AddAsyncTask<VIPKillNPCConfig>();
        AddAsyncTask<LoadingTipConfig>();
        AddAsyncTask<XMZZAchievementConfig>();
        AddAsyncTask<XBGetItemConfig>();
        AddAsyncTask<bossSkillTipsConfig>();
        AddAsyncTask<OSRedAchieveConfig>();
        AddAsyncTask<RedPackConfig>();
        AddAsyncTask<TreasureFindHostConfig>();
        AddAsyncTask<TreasureUpConfig>();
        AddAsyncTask<TreasurePrivilegeConfig>();
        AddAsyncTask<CTGConfig>();
        AddAsyncTask<MapResourcesConfig>();
        AddAsyncTask<FightPowerParamConfig>();
        AddAsyncTask<LoadingFunctionConfig>();
        AddAsyncTask<LoginAdConfig>();
        AddAsyncTask<FreeGoodsConfig>();
        AddAsyncTask<BossRebornConfig>();
        AddAsyncTask<UniquenessArriveConfig>();
        AddAsyncTask<AllPeoplePartyConfig>();
        AddAsyncTask<AllPeoplePartyAwardConfig>();
        AddAsyncTask<NewUniquenessArriveConfig>();
        AddAsyncTask<NewAllPeoplePartyConfig>();
        AddAsyncTask<NewAllPeoplePartyAwardConfig>();
        AddAsyncTask<OrderInfoConfig>();
        AddAsyncTask<TrialExchangeConfig>();
        AddAsyncTask<DogzDungeonConfig>();
        AddAsyncTask<TrialRewardsConfig>();
        AddAsyncTask<DogzEquipPlusConfig>();
        AddAsyncTask<FairyGrabBossConfig>();
        AddAsyncTask<DungeonSpecialStateTimeConfig>();
        AddAsyncTask<DailyQuestSpecialOpenTimeConfig>();
        AddAsyncTask<WHYJRewardConfig>();
        AddAsyncTask<TalentConfig>();
        AddAsyncTask<ChatBubbleBoxConfig>();
        AddAsyncTask<GuardConfig>();
        AddAsyncTask<MarketQueryConfig>();
        AddAsyncTask<TreasureDungeonConfig>();
        AddAsyncTask<LoadingBackGroundConfig>();
        AddAsyncTask<IceLodeStarAwardConfig>();
        AddAsyncTask<TaskPowerConfig>();
        AddAsyncTask<GodWeaponEffectConfig>();
        AddAsyncTask<DungeonHelpBattleConfig>();
        AddAsyncTask<FuncSwitchConfig>();
        AddAsyncTask<AncientRobotNameConfig>();
        AddAsyncTask<CrossServerArenaConfig>();
        AddAsyncTask<GatherSoulConfig>();
        AddAsyncTask<GatherSoulPropertyConfig>();
        AddAsyncTask<GatherSoulComposeConfig>();
        AddAsyncTask<KingTreasureConfig>();
        AddAsyncTask<KingTreasureItemConfig>();
        AddAsyncTask<CrossServerBossConfig>();
        AddAsyncTask<WeekPartyConfig>();
        AddAsyncTask<FashionDressCabinetConfig>();
        AddAsyncTask<FashionDressConfig>();
        AddAsyncTask<WeekPartyPointConfig>();
        AddAsyncTask<SceneReplaceConfig>();
        AddAsyncTask<JadeDynastyTowerConfig>();
        AddAsyncTask<JadeDynastyBossConfig>();
        AddAsyncTask<JadeDynastySuitAttrConfig>();
        AddAsyncTask<JadeDynastyStoneAttrConfig>();
        AddAsyncTask<SkillFrameAnimationConfig>();
        AddAsyncTask<FestivalRedpackTaskConfig>();
        AddAsyncTask<HolidayHomingConfig>();
        AddAsyncTask<HolidayHomingPointConfig>();

        while (!AllCompleted())
        {
            var completedCount = 0;
            for (int i = 0; i < configTasks.Count; i++)
            {
                var task = configTasks[i];
                if (task.state == TaskState.ParseSuccess)
                {
                    completedCount++;
                }
            }

            var allowTaskCount = completedCount <= 8 ? GetMinWorkingTaskCount() : GetMaxWorkingTaskCount();
            var workingCount = 0;
            for (int i = 0; i < configTasks.Count; i++)
            {
                var task = configTasks[i];
                if (task.state > TaskState.None && task.state < TaskState.ParseSuccess)
                {
                    workingCount++;
                }
            }

            if (workingCount < allowTaskCount)
            {
                var leisureCount = allowTaskCount - workingCount;
                var startedTasksCount = 0;
                for (int i = 0; i < configTasks.Count; i++)
                {
                    var task = configTasks[i];
                    if (task.state == TaskState.None)
                    {
                        StartAsyncTask(task);
                        startedTasksCount++;
                    }

                    if (startedTasksCount >= leisureCount)
                    {
                        break;
                    }
                }
            }

            yield return null;
        }

    }

    public void SyncLoadConfigs()
    {
        StartSyncTask<NPCConfig>();
        StartSyncTask<ModelResConfig>();
        StartSyncTask<IconConfig>();
        StartSyncTask<SysInfoConfig>();
        StartSyncTask<LanguageConfig>();
        StartSyncTask<RealmConfig>();
    }

    public bool AllCompleted()
    {
        foreach (var task in configTasks)
        {
            if (task.state != TaskState.ParseSuccess)
            {
                // DesignDebug.LogFormat("未完成是配置解析任务：{0},当前状态：{1}", task.taskName, task.state);
                return false;
            }
        }

        return true;
    }

    public float GetProgress()
    {
        var count = 0;
        foreach (var task in configTasks)
        {
            if (task.state == TaskState.ParseSuccess)
            {
                count++;
            }
        }

        return (float)count / configTasks.Count;
    }

    public int GetTaskCount()
    {
        return configTasks.Count;
    }

    public void ConfigParsePostProcess()
    {
        foreach (var task in configTasks)
        {
            configDictionary[task.token] = task.container;
        }

        inited = true;
    }

    int GetMinWorkingTaskCount()
    {
        switch (Application.platform)
        {
            case RuntimePlatform.Android:
                if (DeviceUtility.cpu >= 4 && DeviceUtility.memory > 3.2f * 1024)
                {
                    return 4;
                }
                else if (DeviceUtility.cpu >= 4 && DeviceUtility.memory > 2.5f * 1024)
                {
                    return 2;
                }
                else
                {
                    return 1;
                }
            case RuntimePlatform.IPhonePlayer:
                if (DeviceUtility.cpu > 1 && DeviceUtility.memory > 1.5f * 1024)
                {
                    return 4;
                }
                else
                {
                    return 1;
                }
            case RuntimePlatform.WindowsEditor:
                return 4;
            default:
                return 1;
        }
    }

    int GetMaxWorkingTaskCount()
    {
        switch (Application.platform)
        {
            case RuntimePlatform.Android:
                if (DeviceUtility.cpu >= 4 && DeviceUtility.memory > 3.2f * 1024)
                {
                    return 20;
                }
                else if (DeviceUtility.cpu >= 4 && DeviceUtility.memory > 2.5f * 1024)
                {
                    return 10;
                }
                else if (DeviceUtility.cpu > 1 && DeviceUtility.memory > 1.5f * 1024)
                {
                    return 4;
                }
                else
                {
                    return 1;
                }
            case RuntimePlatform.IPhonePlayer:
                if (DeviceUtility.cpu > 1 && DeviceUtility.memory > 1.5f * 1024)
                {
                    return 10;
                }
                else
                {
                    return 1;
                }
            case RuntimePlatform.WindowsEditor:
                return 20;
            default:
                return 5;
        }
    }

    ConfigTask AddAsyncTask<T>() where T : ConfigBase, new()
    {
        var typeName = typeof(T).Name;
        var path = string.Empty;
        var fileName = typeName.Substring(0, typeName.Length - 6);

        if (AssetSource.refdataFromEditor)
        {
            path = ResourcesPath.CONFIG_FODLER + "/" + fileName + ".txt";
        }
        else
        {
            path = AssetVersionUtility.GetAssetFilePath(StringUtility.Contact("config/", fileName, ".txt"));
        }

        var task = new ConfigTask(typeof(T), path);
        Action<ConfigTask> launch = (ConfigTask _task) => { ReadFile(_task, OnEndReadFile<T>); };
        task.launch = launch;
        configTasks.Add(task);

        return task;
    }

    void StartAsyncTask(ConfigTask _task)
    {
        _task.state = TaskState.Working;
        _task.launch(_task);
    }

    void ReadFile(ConfigTask _task, Action<ConfigTask> _callBack)
    {
        ThreadPool.QueueUserWorkItem(
            (object _obj) =>
            {
                string[] lines = null;
                try
                {
                    lines = File.ReadAllLines(_task.filePath, Encoding.UTF8);
                    _task.state = TaskState.ReadFileSuccess;
                }
                catch (Exception ex)
                {
                    _task.state = TaskState.ReadFileFailure;
                    DebugEx.Log(ex);
                }
                finally
                {
                    _task.contentLines = lines;
                    if (_callBack != null)
                    {
                        _callBack(_task);
                    }
                }
            }
            );

    }

    void AsyncParseConfig<T>(ConfigTask _task, Action<ConfigTask> _callBack) where T : ConfigBase, new()
    {
        ThreadPool.QueueUserWorkItem(
            (object _obj) =>
            {
                try
                {
                    var count = 0;

                    var container = _task.container as Dictionary<string, ConfigBase>;
                    for (int i = 3; i < _task.contentLines.Length; i++)
                    {
                        var newConfig = new T();
                        newConfig.Parse(_task.contentLines[i]);
                        if (newConfig is IConfigPostProcess)
                        {
                            (newConfig as IConfigPostProcess).OnConfigParseCompleted();
                        }

                        container[newConfig.getKey()] = newConfig;
                        count++;
                        if (count >= 500)
                        {
                            count = 0;
                            Thread.Sleep(30);
                        }
                    }

                    _task.state = TaskState.ParseSuccess;
                }
                catch (Exception ex)
                {
                    _task.state = TaskState.ParseFailure;
                    DebugEx.Log(ex);
                }
                finally
                {
                    if (_callBack != null)
                    {
                        _callBack(_task);
                    }
                }
            }
            );
    }

    private void OnEndReadFile<T>(ConfigTask _task) where T : ConfigBase, new()
    {
        if (isPlaying && _task.state == TaskState.ReadFileFailure)
        {
            Thread.Sleep(30);
            ReadFile(_task, OnEndReadFile<T>);
        }
        else
        {
            _task.capacity = Mathf.Max(_task.contentLines.Length - 3, 0);
            _task.container = new Dictionary<string, ConfigBase>(_task.capacity);
            AsyncParseConfig<T>(_task, OnEndParse<T>);
        }
    }

    private void OnEndParse<T>(ConfigTask _task) where T : ConfigBase, new()
    {
        if (isPlaying && _task.state == TaskState.ParseFailure)
        {
            Debug.LogFormat("配置表解析失败：{0}", _task.taskName);
            Thread.Sleep(30);
            ReadFile(_task, OnEndReadFile<T>);
        }
    }

    private void StartSyncTask<T>() where T : ConfigBase, new()
    {
        var typeName = typeof(T).Name;
        var fileName = typeName.Substring(0, typeName.Length - 6);
        var path = string.Empty;

        if (Application.isEditor || AssetSource.refdataFromEditor)
        {
            path = ResourcesPath.CONFIG_FODLER + "/" + fileName + ".txt";
        }
        else
        {
            path = AssetVersionUtility.GetAssetFilePath(StringUtility.Contact("config/", fileName, ".txt"));
        }

        var task = new ConfigTask(typeof(T), path);
        task.contentLines = File.ReadAllLines(path, Encoding.UTF8);
        if (task.contentLines != null && task.contentLines.Length > 3)
        {
            var length = Mathf.Max(task.contentLines.Length - 3, 0);
            task.capacity = length;
            task.container = new Dictionary<string, ConfigBase>(length);
            task.state = TaskState.ReadFileSuccess;
            SyncParseConfig<T>(task);
        }
        else
        {
            task.state = TaskState.ReadFileFailure;
        }
    }

    private void SyncParseConfig<T>(ConfigTask _task) where T : ConfigBase, new()
    {
        try
        {
            for (int i = 3; i < _task.contentLines.Length; i++)
            {
                var newConfig = new T();
                newConfig.Parse(_task.contentLines[i]);

                if (newConfig is IConfigPostProcess)
                {
                    (newConfig as IConfigPostProcess).OnConfigParseCompleted();
                }

                _task.container[newConfig.getKey()] = newConfig;
            }
        }
        catch (Exception ex)
        {
            DebugEx.Log(ex);
        }
        finally
        {
            _task.state = TaskState.ParseSuccess;
            configDictionary[_task.token] = _task.container;
        }

    }

    public T Get<T>(string _dwTemplateID) where T : ConfigBase, new()
    {
        if (string.IsNullOrEmpty(_dwTemplateID))
        {
            return null;
        }

        var token = typeof(T).MetadataToken;
        if (configDictionary.ContainsKey(token) == false)
        {
            DebugEx.LogErrorFormat("not find the config:{0}", token);
            return null;
        }

        ConfigBase config = null;
        var dic = configDictionary[token];
        if (!dic.ContainsKey(_dwTemplateID))
        {
            DebugEx.LogFormat("not find the config:{0},<color=#ff0000ff>ID:{1}</color>", typeof(T).Name, _dwTemplateID);
        }
        else
        {
            config = dic[_dwTemplateID];
        }

        return config as T;
    }

    public T Get<T>(int _dwTemplateID) where T : ConfigBase, new()
    {
        return Get<T>(_dwTemplateID.ToString());
    }

    public bool ContainKey<T>(int _id)
    {
        return ContainKey<T>(_id.ToString());
    }

    public bool ContainKey<T>(string _key)
    {
        if (string.IsNullOrEmpty(_key))
        {
            return false;
        }

        var token = typeof(T).MetadataToken;
        if (configDictionary.ContainsKey(token) == false)
        {
            return false;
        }

        var dic = configDictionary[token];
        return dic.ContainsKey(_key);
    }

    public List<string> GetAllKeys<T>() where T : ConfigBase
    {
        var token = typeof(T).MetadataToken;
        if (!configDictionary.ContainsKey(token))
        {
            DebugEx.LogErrorFormat("not find the dic of config: {0}", typeof(T).Name);
            return null;
        }

        var dicTemplate = configDictionary[token];
        return new List<string>(dicTemplate.Keys);
    }

    public List<T> GetAllValues<T>() where T : ConfigBase, new()
    {
        var token = typeof(T).MetadataToken;
        if (!configDictionary.ContainsKey(token))
        {
            DebugEx.LogErrorFormat("not find the dic of config: {0}", typeof(T).Name);
            return null;
        }

        var configs = new List<T>();
        var dicTemplate = configDictionary[token];
        foreach (var value in dicTemplate.Values)
        {
            configs.Add(value as T);
        }

        return configs;
    }

    class ConfigTask
    {
        public readonly Type type;
        public readonly int token;
        public readonly string taskName;
        public readonly string filePath;

        public Action<ConfigTask> launch;
        public int capacity = 0;
        public string[] contentLines;
        public Dictionary<string, ConfigBase> container;
        public TaskState state = TaskState.None;

        public ConfigTask(Type _type, string _filePath)
        {
            type = _type;
            taskName = type.Name;
            token = type.MetadataToken;

            filePath = _filePath;
        }
    }

    public enum TaskState
    {
        None = 0,
        Working = 1,
        ReadFileSuccess = 2,
        ReadFileFailure = 3,
        ParseFailure = 4,
        ParseSuccess = 5,
    }

    private void OnApplicationOut()
    {
        isPlaying = false;
    }

}