//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Thursday, November 09, 2017
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using UnityEngine.UI;
using TableConfig;
using System;

namespace Snxxz.UI
{

    public class RuneTowerBehaviour : MonoBehaviour
    {
        [SerializeField] Image m_TowerName;
        [SerializeField] UIEffect m_TowerEffect;
        [SerializeField] UIAlphaTween m_TowerNameAlphaAnimation;

        [SerializeField] ScrollRect m_Tower;
        [SerializeField] UIEffect m_DaoTaEffect;

        RectTransform m_RectTransform;
        RectTransform rectTransform { get { return m_RectTransform ?? (this.transform as RectTransform); } }

        float topHeight = 0f;
        float floorHeight = 0f;
        float bottomHeight = 0f;

        float targetNormalizePosition = 0f;
        float refNormalizePosition = 0f;

        GameObject towerTop = null;
        GameObject towerBottom;
        List<TowerFloorBehaviour> floors = new List<TowerFloorBehaviour>();

        Action onTowerCollapseCompleted;

        RuneTowerModel model { get { return ModelCenter.Instance.GetModel<RuneTowerModel>(); } }

        public void Display(int _towerId)
        {
            var scrollRectTransform = m_Tower.transform as RectTransform;
            scrollRectTransform.localScale = Vector3.one;
            scrollRectTransform.anchoredPosition = Vector2.zero;
            m_TowerNameAlphaAnimation.SetEndState();
            DisplayTowerBaseInfo(_towerId);
            MoveToTargetFloor();
        }

        public void Dispose()
        {
            m_Tower.scrollSensitivity = 1f;
            onTowerCollapseCompleted = null;
            StopAllCoroutines();
        }

        public void TowerCollapseShow(int _oldTowerId, int _newTowerId, Action _onTowerCollapseCompleted)
        {
            onTowerCollapseCompleted = _onTowerCollapseCompleted;
            var towerConfig = ConfigManager.Instance.GetTemplate<RuneTowerConfig>(_oldTowerId);
            m_TowerName.SetSprite(towerConfig.NameIcon);

            StopCoroutine("Co_CollapseShow");
            StartCoroutine("Co_CollapseShow", _newTowerId);

            model.unLockShowTower = 0;
        }

        void MoveToTargetFloor()
        {
            StopCoroutine("Co_MoveToSelectedFloor");
            StartCoroutine("Co_MoveToSelectedFloor");
        }

        private float GetFloorNormalizePosition(int _floor)
        {
            var floorConfig = ConfigManager.Instance.GetTemplate<RuneTowerFloorConfig>(_floor);
            var targetNormalizePosition = (bottomHeight + floorHeight * (floorConfig.FloorIndex - 0.5f) - rectTransform.rect.height * 0.5f)
                            / (m_Tower.content.rect.height - rectTransform.rect.height);

            return Mathf.Clamp01(targetNormalizePosition);
        }

        IEnumerator Co_MoveToSelectedFloor()
        {
            yield return null;
            yield return null;
            targetNormalizePosition = GetFloorNormalizePosition(model.currentFloor);
            while (Mathf.Abs(m_Tower.verticalNormalizedPosition - targetNormalizePosition) > 0.001f)
            {
                m_Tower.verticalNormalizedPosition = Mathf.SmoothDamp(m_Tower.verticalNormalizedPosition, targetNormalizePosition, ref refNormalizePosition, 0.1f);
                yield return null;
            }
        }

        IEnumerator Co_CollapseShow(int _towerId)
        {
            m_Tower.scrollSensitivity = 0f;
            var scrollRectTransform = m_Tower.transform as RectTransform;
            scrollRectTransform.localScale = Vector3.zero;

            m_DaoTaEffect.Play();
            m_TowerNameAlphaAnimation.Play(true);

            yield return new WaitForSeconds(6f);

            DisplayTowerBaseInfo(_towerId);

            var floorCount = model.GetFloorCount(_towerId);
            var totalHeight = (bottomHeight + topHeight + floorHeight * floorCount - 1);

            scrollRectTransform.anchoredPosition = scrollRectTransform.anchoredPosition.SetY(-totalHeight);
            scrollRectTransform.localScale = Vector3.one;

            yield return null;
            m_Tower.verticalNormalizedPosition = GetFloorNormalizePosition(model.currentFloor);

            var positionRef = 0f;
            while (Mathf.Abs(scrollRectTransform.anchoredPosition.y) > 1f)
            {
                var targetY = Mathf.SmoothDamp(scrollRectTransform.anchoredPosition.y, 0, ref positionRef, 0.4f);
                scrollRectTransform.anchoredPosition = scrollRectTransform.anchoredPosition.SetY(targetY);
                yield return null;
            }

            scrollRectTransform.anchoredPosition = scrollRectTransform.anchoredPosition.SetY(0);
            m_Tower.scrollSensitivity = 1f;

            m_TowerNameAlphaAnimation.Play();
            m_TowerEffect.Play();

            if (onTowerCollapseCompleted != null)
            {
                onTowerCollapseCompleted();
                onTowerCollapseCompleted = null;
            }
        }

        private void DisplayTowerBaseInfo(int _towerId)
        {
            var towerConfig = ConfigManager.Instance.GetTemplate<RuneTowerConfig>(_towerId);
            m_TowerName.SetSprite(towerConfig.NameIcon);

            var floorCount = model.GetFloorCount(_towerId);

            if (towerTop == null)
            {
                towerTop = UIUtility.CreateWidget("RuneTower_Top", "Top");
                towerTop.transform.SetParentEx(m_Tower.content, Vector3.zero, Quaternion.identity, Vector3.one);
                towerTop.transform.SetAsFirstSibling();
                topHeight = ((RectTransform)towerTop.transform).rect.height;
            }

            var topFloorBehaviour = towerTop.AddMissingComponent<TowerFloorBehaviour>();
            topFloorBehaviour.Display(model.GetFloorId(model.currentTower, floorCount));

            var normalFloorCount = floorCount - 1;
            if (floors.Count < normalFloorCount)
            {
                var floorPrefab = UILoader.LoadPrefab("RuneTower_Floor");
                floorHeight = ((RectTransform)floorPrefab.transform).rect.height;
                for (int i = 0; i < normalFloorCount; i++)
                {
                    var instance = Instantiate<GameObject>(floorPrefab);
                    var floorBehaviour = instance.AddMissingComponent<TowerFloorBehaviour>();
                    instance.transform.SetParentEx(m_Tower.content, Vector3.zero, Quaternion.identity, Vector3.one);
                    floors.Add(floorBehaviour);
                }
            }

            for (int i = 0; i < normalFloorCount; i++)
            {
                var floor = floors[i];
                if (i < normalFloorCount)
                {
                    floor.gameObject.SetActive(true);
                    floor.towerBehaviour = this;
                    floor.Display(model.GetFloorId(model.currentTower, normalFloorCount - i));
                }
                else
                {
                    floor.gameObject.SetActive(false);
                }
            }

            if (towerBottom == null)
            {
                towerBottom = UIUtility.CreateWidget("RuneTower_Bottom", "Bottom");
                towerBottom.transform.SetParentEx(m_Tower.content, Vector3.zero, Quaternion.identity, Vector3.one);
                towerBottom.transform.SetAsLastSibling();
                bottomHeight = ((RectTransform)towerBottom.transform).rect.height;
            }

        }

        private void OnDisable()
        {
            StopAllCoroutines();
        }
    }

}