using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

namespace vnxbqy.UI
{
    public class AlchemySortBehaviour : MonoBehaviour
    {
        [SerializeField] AlchemySortType m_AlchemySortType;
        [SerializeField] Button m_Func;
        [SerializeField] Image m_Arrow;
        [SerializeField] Transform m_ContainerSort;
        [SerializeField] ScrollerController m_Controller;

        List<int> m_Sorts = new List<int>();

        Dictionary<int, bool> m_SortEnables = new Dictionary<int, bool>();

        bool m_OpenSort = false;
        bool openSort
        {
            get { return m_OpenSort; }
            set
            {
                if (m_OpenSort != value)
                {
                    m_OpenSort = value;
                    OnSortChange();
                }
            }
        }

        public static event Action onSortRefresh;


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

        private void Awake()
        {
            m_Controller.OnRefreshCell += OnRefreshCell;
            m_Func.SetListener(() =>
            {
                DisplaySorts();
            });
        }

        public void Display()
        {
            m_ContainerSort.SetActive(false);
            m_OpenSort = false;

            if (m_Sorts.Count == 0)
            {
                switch (m_AlchemySortType)
                {
                    case AlchemySortType.AlchemyType:
                        m_Sorts.Add((int)AlchemyType.Normal);
                        m_Sorts.Add((int)AlchemyType.Fairy);
                        break;
                    case AlchemySortType.Quality:
                        var qualities = model.GetDrugQualitys();
                        m_Sorts.AddRange(qualities);
                        break;
                }
                m_Sorts.RemoveAll((x) => { return x == 0; });
            }

            SetSortEnable(0, true);
            DisplaySortState();
        }

        void DisplaySortState()
        {
            m_Arrow.transform.localEulerAngles = new Vector3(0, 0, openSort ? 0 : 180);
        }

        void DisplaySorts()
        {
            m_ContainerSort.SetActive(true);
            if (m_Controller.GetNumberOfCells(m_Controller.m_Scorller) == 0)
            {
                m_Controller.Refresh();
                m_Controller.AddCell(ScrollerDataType.Header, 0);
                for (int i = 0; i < m_Sorts.Count; i++)
                {
                    m_Controller.AddCell(ScrollerDataType.Header, m_Sorts[i]);
                }
                m_Controller.Restart();
            }
            else
            {
                m_Controller.JumpIndex(0);
                m_Controller.m_Scorller.RefreshActiveCellViews();
            }
        }

        public bool IsSortEnabled(int sort)
        {
            if (sort == 0)
            {
                var allEnabled = true;
                foreach (var _sort in m_Sorts)
                {
                    if (!IsSortEnabled(_sort))
                    {
                        allEnabled = false;
                        break;
                    }
                }
                return allEnabled;
            }
            return m_SortEnables.ContainsKey(sort) && m_SortEnables[sort];
        }

        public void SetSortEnable(int sort, bool enabled, bool single = true)
        {
            if (sort == 0)
            {
                foreach (var _sort in m_Sorts)
                {
                    SetSortEnable(_sort, enabled, false);
                }
                m_Controller.m_Scorller.RefreshActiveCellViews();
                return;
            }
            m_SortEnables[sort] = enabled;
            if (single)
            {
                m_Controller.m_Scorller.RefreshActiveCellViews();
            }
        }

        private void OnRefreshCell(ScrollerDataType type, CellView cell)
        {
            var sortCell = cell as AlchemySortCell;
            sortCell.Display(this, m_AlchemySortType, cell.index);
        }

        private void OnSortChange()
        {
            DisplaySortState();
            if (!openSort)
            {
                if (onSortRefresh != null)
                {
                    onSortRefresh();
                }
            }
        }

        private void LateUpdate()
        {
            openSort = m_ContainerSort.gameObject.activeSelf;
        }

        public enum AlchemySortType
        {
            AlchemyType,
            Quality,
        }
    }
}