using UnityEngine;
using System.Collections.Generic;
using System.Reflection;
using System;

namespace UltraControls
{
    using MapCtrlInfo   = Dictionary<string, ControlInfo>;
    using MapCtrl       = Dictionary<string, Control>;

    public class UltraGetter : MonoBehaviour
    {
        public delegate void OnCompletedSetupGetter(UltraGetter getter);
        public event OnCompletedSetupGetter EventComplemtedSetupGetter;

        public bool is_start
        {
            get { return m_is_started; }
            set
            {
                m_is_started = value;
                if (!m_is_started && m_handle != Handler.InvalidHandle)
                {
                    mf_Destroy();
                }

            }
        }

        public string ultracontros_name
        {
            get { return m_name; }
            set
            {
                if (m_is_started && m_handle != Handler.InvalidHandle)
                {
                    mf_Destroy();
                }

                m_name = value;
                //m_relative_filepath_settings_default = Path.Combine(Utils.GetRelativeDefaultDir(), mf_PleaseCallMyRealName() + ".json");
            }
        }

        public bool AddControlInfo< T > (string name, T val, T min, T max)
        {
            if (is_start)
            {
                m_need_restart = true;
            }

            if (m_map_ctrl_info.ContainsKey(name))
            {
                return false;
            }

            m_map_ctrl_info.Add(name, Factroy.CreateInfo<T>(name, val, min, max) );
            return true;
        }

        public bool AddControlInfo<T>(string name, T val)
        {
            if (is_start)
            {
                m_need_restart = true;
            }

            if (m_map_ctrl_info.ContainsKey(name))
            {
                return false;
            }

            m_map_ctrl_info.Add(name, Factroy.CreateInfo<T>(name, val));
            return true;
        }

        public void RemoveControlInfo(string name)
        {
            if (is_start)
            {
                m_need_restart = true;
            }

            m_map_ctrl_info.Remove(name);
        }

        public ParamGetter<T> GetParamGetter<T>(string name)
        {
            Control ctrl;
            if (!m_map_ctrl.TryGetValue(name, out ctrl))
            {
                return null;
            }

            return ctrl.CreateParamGetter<T>();
        }

        void Start()
        {

        }

        void Update()
        {
            mf_Update();   
        }

#if UNITY_EDITOR
        public void UpdateByUltraGetterEditor()
        {
            mf_Update();
        }

#endif
        //===============================================================
        //Private member or function
        //===============================================================
        private uint m_handle = Handler.InvalidHandle;

        [SerializeField]
        private string m_name = "UnityGetter";

        [SerializeField]
        private bool m_is_started;

        private bool m_need_restart;

        private MapCtrlInfo     m_map_info;
        private MapCtrl         m_map;
        private Control[]       m_controls;
        private IDelegatable[]  m_delegates;

        interface IDelegatable
        {
            bool Setup(Control[] ctrls);
            void Invoke();
        }

        public class DelegateFieldSetValue< T >: IDelegatable
        {
            public DelegateFieldSetValue(object mono, FieldInfo field, string name)
            {
                m_method    = typeof(FieldInfo).GetMethod("SetValue", new[] { typeof(object), typeof(object) });
                m_instance  = field;
                m_mono      = mono;
                m_name      = name;
            }

            public bool Setup(Control[] ctrls)
            {
                foreach(Control ctrl in ctrls)
                {
                    if (ctrl.name == m_name)
                    {
                        m_param_getter = ctrl.CreateParamGetter< T >();
                        return true;
                    }
                }

                return false;
            }

            public void Invoke()
            {
                //m_dele.DynamicInvoke(new object[] { m_mono, m_param_getter.val});
                m_method.Invoke(m_instance, new object[] { m_mono, m_param_getter.val });
            }

            private string              m_name;
            private MethodInfo          m_method;
            private object              m_instance;
            private object              m_mono;
            private ParamGetter< T >    m_param_getter;
        }

        private MapCtrlInfo m_map_ctrl_info
        {
            get
            {
                if (m_map_info == null)
                {
                    m_map_info = new MapCtrlInfo();
                }

                return m_map_info;

            }
        }

        private MapCtrl m_map_ctrl
        {
            get
            {
                if (m_map == null)
                {
                    m_map = new MapCtrl();
                }

                return m_map;
            }
        }

        private bool mf_HasHandle()
        {
            return m_handle != Handler.InvalidHandle && Handler.singleton.IsExisted(m_handle);
        }

        private void mf_Restart()
        {
            is_start = false;
            is_start = true;

            m_need_restart = false;
        }

        private void mf_Update()
        {
            if (m_need_restart)
            {
                mf_Restart();
            }

            if (!m_is_started)
            {
                return;
            }

            if (!mf_HasHandle())
            {
                m_handle = Handler.singleton.Create(m_name, 32);
                return;
            }

            if (m_controls == null)
            {
                List<ControlInfo> lst_info = new List<ControlInfo>();
                List<IDelegatable> lst_dele = new List<IDelegatable>();

                mf_FindAttribues2(lst_info, lst_dele);
                
                lst_info.AddRange(m_map_ctrl_info.Values);

                m_controls = Handler.singleton.SetupGetter(m_handle, lst_info);
                if (m_controls != null)
                {
                    foreach(IDelegatable dele in lst_dele)
                    {
                        if(!dele.Setup(m_controls))
                        {
                            lst_dele.Remove(dele);
                        }
                    }

                    if (lst_dele.Count > 0)
                    {
                        m_delegates = lst_dele.ToArray();
                    }

                    foreach (Control ctrl in m_controls)
                    {
                        m_map_ctrl.Add(ctrl.name, ctrl);
                    }

                    if (EventComplemtedSetupGetter != null)
                    {
                        EventComplemtedSetupGetter(this);
                    }
                }
                
                return;
            }

            bool yes = Handler.singleton.CheckControls(m_handle);
            if (!yes)
            {
                return;
            }

            if (m_delegates == null)
            {
                return;
            }

            foreach(IDelegatable dele in m_delegates)
            {
                dele.Invoke();
            }
        }

        private void mf_Destroy()
        {
            if (Handler.is_singleton_lived)
            {
                Handler.singleton.Destroy(m_handle);
            }

            m_handle = Handler.InvalidHandle;
            m_controls = null;
            m_delegates = null;

            if (m_map != null)
            {
                m_map.Clear();
            }
        }

        /*
        private void mf_FindAttribuesFromBehavior(List<ControlInfo> lst_info, List<IDelegatable> lst_delegate, object behavior, BindingFlags bingingFlag)
        {
            foreach (FieldInfo field in (behavior.GetType().GetFields(bingingFlag)))
            {
                UltraControlsAttribute attr_ultracontrols = null;
                RangeAttribute attr_range = null;

                foreach (object attribute in field.GetCustomAttributes(true))
                {
                    {
                        var attr = attribute as UltraControlsAttribute;
                        if (attr != null && attr.binding_flag == UltraControlsAttribute.BindingFlag.Getter)
                        {
                            attr_ultracontrols = attr;
                            continue;
                        }
                    }

                    {
                        var attr = attribute as RangeAttribute;
                        if (attr != null)
                        {
                            attr_range = attr;
                        }
                    }

                }//attributes

                if (attr_ultracontrols == null)
                {
                    continue;
                }

                ControlInfo info = null;
                IDelegatable dele = null;
                {
                    string name = (attr_ultracontrols.control_name == "") ? field.Name : attr_ultracontrols.control_name;
                    if (field.FieldType == typeof(string))
                    {
                        info = Factroy.CreateInfo(name, (string)field.GetValue(behavior));
                        dele = new DelegateFieldSetValue<string>(behavior, field, name);
                    }
                    else if (field.FieldType == typeof(float))
                    {
                        if (attr_range == null)
                        {
                            info = Factroy.CreateInfo(name, (float)field.GetValue(behavior));
                        }
                        else
                        {
                            info = Factroy.CreateInfo(name, (float)field.GetValue(behavior), attr_range.min, attr_range.max);
                        }

                        dele = new DelegateFieldSetValue<float>(behavior, field, name);
                    }
                    else if (field.FieldType == typeof(int))
                    {
                        if (attr_range == null)
                        {
                            info = Factroy.CreateInfo(name, (int)field.GetValue(behavior));
                        }
                        else
                        {
                            info = Factroy.CreateInfo(name, (int)field.GetValue(behavior), (int)attr_range.min, (int)attr_range.max);
                        }

                        dele = new DelegateFieldSetValue<int>(behavior, field, name);
                    }
                    else if (field.FieldType == typeof(Vector2))
                    {
                        info = Factroy.CreateInfo(name, (Vector2)field.GetValue(behavior));
                        dele = new DelegateFieldSetValue<Vector2>(behavior, field, name);
                    }
                    else if (field.FieldType == typeof(Vector3))
                    {
                        info = Factroy.CreateInfo(name, (Vector3)field.GetValue(behavior));
                        dele = new DelegateFieldSetValue<Vector3>(behavior, field, name);
                    }
                    else if (field.FieldType == typeof(Vector4))
                    {
                        info = Factroy.CreateInfo(name, (Vector4)field.GetValue(behavior));
                        dele = new DelegateFieldSetValue<Vector4>(behavior, field, name);
                    }
                    else if (field.FieldType == typeof(Color))
                    {
                        info = Factroy.CreateInfo(name, (Color)field.GetValue(behavior));
                        dele = new DelegateFieldSetValue<Color>(behavior, field, name);
                    }
                    else if (field.FieldType == typeof(Color32))
                    {
                        info = Factroy.CreateInfo(name, (Color32)field.GetValue(behavior));
                        dele = new DelegateFieldSetValue<Color32>(behavior, field, name);
                    }

                    if (info != null)
                    {
                        lst_info.Add(info);
                        lst_delegate.Add(dele);
                    }

                }

            }//fields
        }
        */

        /*
        private void mf_FindAttribuesFromComponent< Component > (List<ControlInfo> lst_info, List<IDelegatable> lst_delegate, BindingFlags bingingFlag)
        {
            var components = gameObject.GetComponentsInChildren< Component >(true);

            foreach (Component component in components)
            {
                if (component == null)
                    continue;

                mf_FindAttribuesFromBehavior(lst_info, lst_delegate, component, bingingFlag);

            }//monos
        }
        */

        private void mf_FindAttribues2(List<ControlInfo> lst_info, List<IDelegatable> lst_delegate)
        {
            Utils.FindUltraControlsAttribues(this, UltraControlsAttribute.BindingFlag.Getter, 
            (object sender, object behavior, FieldInfo field, UltraControlsAttribute attr_ultracontrols, RangeAttribute attr_range) =>
            {
                ControlInfo info = null;
                IDelegatable dele = null;
                {
                    string name = (attr_ultracontrols.control_name == "") ? field.Name : attr_ultracontrols.control_name;
                    if (field.FieldType == typeof(string))
                    {
                        info = Factroy.CreateInfo(name, (string)field.GetValue(behavior));
                        dele = new DelegateFieldSetValue<string>(behavior, field, name);
                    }
                    else if (field.FieldType == typeof(float))
                    {
                        if (attr_range == null)
                        {
                            info = Factroy.CreateInfo(name, (float)field.GetValue(behavior));
                        }
                        else
                        {
                            info = Factroy.CreateInfo(name, (float)field.GetValue(behavior), attr_range.min, attr_range.max);
                        }

                        dele = new DelegateFieldSetValue<float>(behavior, field, name);
                    }
                    else if (field.FieldType == typeof(int))
                    {
                        if (attr_range == null)
                        {
                            info = Factroy.CreateInfo(name, (int)field.GetValue(behavior));
                        }
                        else
                        {
                            info = Factroy.CreateInfo(name, (int)field.GetValue(behavior), (int)attr_range.min, (int)attr_range.max);
                        }

                        dele = new DelegateFieldSetValue<int>(behavior, field, name);
                    }
                    else if (field.FieldType == typeof(Vector2))
                    {
                        info = Factroy.CreateInfo(name, (Vector2)field.GetValue(behavior));
                        dele = new DelegateFieldSetValue<Vector2>(behavior, field, name);
                    }
                    else if (field.FieldType == typeof(Vector3))
                    {
                        info = Factroy.CreateInfo(name, (Vector3)field.GetValue(behavior));
                        dele = new DelegateFieldSetValue<Vector3>(behavior, field, name);
                    }
                    else if (field.FieldType == typeof(Vector4))
                    {
                        info = Factroy.CreateInfo(name, (Vector4)field.GetValue(behavior));
                        dele = new DelegateFieldSetValue<Vector4>(behavior, field, name);
                    }
                    else if (field.FieldType == typeof(Color))
                    {
                        info = Factroy.CreateInfo(name, (Color)field.GetValue(behavior));
                        dele = new DelegateFieldSetValue<Color>(behavior, field, name);
                    }
                    else if (field.FieldType == typeof(Color32))
                    {
                        info = Factroy.CreateInfo(name, (Color32)field.GetValue(behavior));
                        dele = new DelegateFieldSetValue<Color32>(behavior, field, name);
                    }

                    if (info != null)
                    {
                        lst_info.Add(info);
                        lst_delegate.Add(dele);
                    }
                }

            });

            //Utils.FindUltraControlsAttribues<  >
        }

        /*
        private void mf_FindAttribues(List<ControlInfo> lst_info, List<IDelegatable> lst_delegate)
        {
            BindingFlags bingingFlag = BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public;
            mf_FindAttribuesFromComponent< MonoBehaviour >(lst_info, lst_delegate, bingingFlag);

            var animators = gameObject.GetComponentsInChildren<Animator>(true);
            foreach (Animator animator in animators)
            {
                if (animator == null)
                    continue;

                var behaviours = animator.GetBehaviours<StateMachineBehaviour>();
                foreach(StateMachineBehaviour behaviour in behaviours)
                {
                    mf_FindAttribuesFromBehavior(lst_info, lst_delegate, behaviour, bingingFlag);

                }//behaviours

            }//animators

        }// mf_FindAttribues()
        */
    }
}