//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Monday, September 04, 2017
//--------------------------------------------------------

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using LitJson;
using System.Text.RegularExpressions;

namespace Snxxz.UI
{

    public class LoadingWin : Window
    {
        public static int targetMapResId = 0;
        public static bool isCrossServerOneVsOne = false;

        [SerializeField] RawImage m_ScreenShotCut;
        [SerializeField] UIAlphaTween m_UIAlphaTween;

        [SerializeField] RectTransform m_ContainerNormal;
        [SerializeField] Image m_BackGround;
        [SerializeField] RectTransform m_ContainerFunctions;
        [SerializeField] LoadingFunctionShow[] m_FunctionShows;
        [SerializeField] RectTransform m_ContainerProgress;
        [SerializeField] SmoothSlider m_ProgressSlider;
        [SerializeField] RectTransform m_ContainerMapName;
        [SerializeField] Image m_MapName;
        [SerializeField] RectTransform m_ContainerMapDescription;
        [SerializeField] Image m_MapDescription;

        [SerializeField] RectTransform m_CrossServerOneVsOne;
        [SerializeField] Image m_CrossServerOneVsOneBg;
        [SerializeField] Text m_MyName;
        [SerializeField] Text m_OpponentName;

        float refProgress = 0f;
        float overTimer = 0f;

        LoadingType loadingType = LoadingType.Normal;

        #region Built-in
        protected override void BindController()
        {
        }

        protected override void AddListeners()
        {
        }

        protected override void OnPreOpen()
        {
            m_ContainerNormal.gameObject.SetActive(false);
            m_CrossServerOneVsOne.gameObject.SetActive(false);
        }

        protected override void OnAfterOpen()
        {
        }

        protected override void OnPreClose()
        {
            isCrossServerOneVsOne = false;

            CameraUtility.StopShotCut(m_ScreenShotCut);
            if (!AssetSource.uiFromEditor)
            {
                AssetBundleUtility.Instance.UnloadAssetBundle("ui/sprite/loading", true, false);
                AssetBundleUtility.Instance.UnloadAssetBundle("ui/sprite/loadingbg", true, false);
            }
        }

        protected override void OnAfterClose()
        {
        }

        protected override void OnActived()
        {
            base.OnActived();

            CameraUtility.ScreenShotCut(m_ScreenShotCut, null, false, false);
            m_UIAlphaTween.Play(Display);
        }

        #endregion

        protected override void LateUpdate()
        {
            base.LateUpdate();
            if (loadingType == LoadingType.Normal)
            {
                if (StageLoad.Instance.progress + 0.1f > refProgress)
                {
                    refProgress = Mathf.Clamp01(StageLoad.Instance.progress + 0.1f);
                }

                m_ProgressSlider.value = refProgress;
            }

            overTimer += Time.deltaTime;
            if (overTimer > 15f)
            {
                overTimer -= 5f;

                var loginModel = ModelCenter.Instance.GetModel<LoginModel>();
                if (!loginModel.busy && !CrossServerLogin.Instance.busy && !StageLoad.Instance.isLoading)
                {
                    WindowCenter.Instance.Close<LoadingWin>();
                }
            }

        }

        private void Display()
        {
            overTimer = 0f;
            refProgress = 0f;
            var useDefautBackGround = false;
            if (!AssetSource.uiFromEditor)
            {
                var assetVersion = AssetVersionUtility.GetAssetVersion("ui/sprite/loadingbg");
                if (assetVersion == null || !assetVersion.localValid)
                {
                    useDefautBackGround = true;
                }
            }

            if (isCrossServerOneVsOne)
            {
                loadingType = LoadingType.CrossServerOneOne;
            }
            else
            {
                loadingType = LoadingType.Normal;
            }

            if (loadingType == LoadingType.CrossServerOneOne)
            {
                if (useDefautBackGround)
                {
                    var sprite = BuiltInLoader.LoadSprite("Launch_1");
                    m_CrossServerOneVsOneBg.overrideSprite = sprite;
                }
                else
                {
                    m_CrossServerOneVsOneBg.SetSprite("CrossServerOneVsOne_LoadingBG");
                }

                m_ContainerNormal.gameObject.SetActive(false);
                m_CrossServerOneVsOne.gameObject.SetActive(true);

                m_MyName.text = CrossServerLogin.Instance.oneVsOnePlayerData.myName;
                m_OpponentName.text = CrossServerLogin.Instance.oneVsOnePlayerData.opponentName;
            }
            else
            {
                m_ContainerNormal.gameObject.SetActive(true);
                m_CrossServerOneVsOne.gameObject.SetActive(false);

                if (useDefautBackGround)
                {
                    var sprite = BuiltInLoader.LoadSprite("Launch_1");
                    m_BackGround.overrideSprite = sprite;
                    m_ContainerMapName.gameObject.SetActive(false);
                    m_ContainerMapDescription.gameObject.SetActive(false);
                    m_ContainerFunctions.gameObject.SetActive(false);
                }
                else
                {
                    var playerLevel = PlayerDatas.Instance.baseData.LV == 0 ? PlayerDatas.Instance.loginInfo.LV : PlayerDatas.Instance.baseData.LV;
                    var mapResConfig = MapResourcesConfig.Get(targetMapResId);
                    if (mapResConfig != null)
                    {
                        var loadingBackGroudConfig = LoadingBackGroundConfig.Get(mapResConfig.DataID, mapResConfig.LineID);
                        if (loadingBackGroudConfig != null && loadingBackGroudConfig.icons.Length > 0)
                        {
                            var icons = new List<string>();
                            var json = JsonMapper.ToObject(loadingBackGroudConfig.levelLimit);

                            for (var i = 0; i < loadingBackGroudConfig.icons.Length; i++)
                            {
                                var icon = loadingBackGroudConfig.icons[i];
                                if (json.Keys.Contains(icon))
                                {
                                    var min = 0;
                                    var max = int.MaxValue;
                                    var levelLimit = json[icon].ToString();
                                    var levelsMatch = Regex.Matches(levelLimit, "\\d+");
                                    if (levelsMatch.Count > 0)
                                    {
                                        min = int.Parse(levelsMatch[0].Value);
                                    }

                                    if (levelsMatch.Count > 1)
                                    {
                                        max = int.Parse(levelsMatch[1].Value);
                                    }

                                    if (playerLevel > min && playerLevel < max)
                                    {
                                        icons.Add(icon);
                                    }
                                }
                                else
                                {
                                    icons.Add(icon);
                                }
                            }

                            var randomIndex = UnityEngine.Random.Range(0, loadingBackGroudConfig.icons.Length > 1 ? icons.Count + 1 : 1);
                            if (randomIndex == icons.Count)
                            {
                                m_BackGround.SetSprite(GeneralDefine.LoadLV);
                                m_ContainerFunctions.gameObject.SetActive(true);
                                var functions = GetShowFunctions(playerLevel);
                                for (int i = 0; i < m_FunctionShows.Length; i++)
                                {
                                    var show = m_FunctionShows[i];
                                    show.Display(functions[i]);
                                }
                            }
                            else
                            {
                                m_BackGround.SetSprite(icons[randomIndex]);
                                m_ContainerFunctions.gameObject.SetActive(false);
                            }

                            if (loadingBackGroudConfig != null && !string.IsNullOrEmpty(loadingBackGroudConfig.name))
                            {
                                m_ContainerMapName.gameObject.SetActive(true);
                                m_MapName.SetSprite(loadingBackGroudConfig.name);
                            }
                            else
                            {
                                m_ContainerMapName.gameObject.SetActive(false);
                            }

                            if (loadingBackGroudConfig != null && !string.IsNullOrEmpty(loadingBackGroudConfig.description))
                            {
                                m_ContainerMapDescription.gameObject.SetActive(true);
                                m_MapDescription.SetSprite(loadingBackGroudConfig.description);
                            }
                            else
                            {
                                m_ContainerMapDescription.gameObject.SetActive(false);
                            }

                        }
                    }
                }

                if (Application.platform == RuntimePlatform.IPhonePlayer)
                {
                    m_ContainerProgress.gameObject.SetActive(false);
                }
                else
                {
                    m_ContainerProgress.gameObject.SetActive(true);
                    m_ProgressSlider.ResetValue(0f);
                }
            }
        }

        private List<int> GetShowFunctions(int _level)
        {
            var configs = LoadingFunctionConfig.GetValues();
            var functions = new List<int>() { configs[0].ID, configs[1].ID, configs[2].ID, configs[3].ID };
            for (int i = 4; i < configs.Count; i++)
            {
                var config = LoadingFunctionConfig.Get(functions[2]);
                if (_level >= config.Level)
                {
                    functions.RemoveAt(0);
                    functions.Add(configs[i].ID);
                }
            }

            return functions;
        }


        public enum LoadingType
        {
            Normal,
            CrossServerOneOne,
        }

    }

}