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

namespace Bro.Common.Procedure
{
    /// <summary>
    /// IO数据状态
    /// </summary>
    public enum IODStat
    {
        IODSUndo,
        IODSDoing,
        IODSDone,
    }

    /// <summary>
    /// IO数据基类
    /// </summary>
    public class IODataBase
    {
        #region 常量

        // 默认的输入处理函数名称
        public const string DFT_HANDLE_METHOD_NAME  = "HandleRequest";
        
        #endregion

        #region 属性

        // 消息处理者
        public List<object>     Handlers {get;set;}

        public IODStat          Stat { get { return curStat; }}

        // 消息描述
        public string           Desp { get;set; }

        // 创建时间
        public DateTime         CreateTime { get;set; }

        // 处理开始时间
        public DateTime         BeginTime { get;set; }

        // 处理完成时间
        public DateTime         EndTime { get;set; }

        // 用户数据
        public object           Data { get;set; }

        #endregion 

        #region 成员变量

        private IODStat       curStat = IODStat.IODSUndo;


        #endregion

        #region 结构体

        public IODataBase()
        {
            Handlers    = null;
            curStat     = IODStat.IODSUndo;

            CreateTime  = DateTime.Now;
            BeginTime   = DateTime.MinValue;
            EndTime     = DateTime.MinValue;

            Desp        = this.GetType().ToString();
            Data        = null;
        }

        public IODataBase(List<object> handlers, string desp, object userData)
        {
            Handlers        = handlers;
            curStat         = IODStat.IODSUndo;

            CreateTime      = DateTime.Now;
            BeginTime       = DateTime.MinValue;
            EndTime         = DateTime.MinValue;

            this.Desp       = desp;
            this.Data       = userData;
        }

        #endregion

        #region 方法

        /// <summary>
        /// 派遣函数，利用反射机制自动派遣给输入处理者
        /// 
        /// 处理方法
        /// 1. 遍历数据处理者
        /// 2. 检察处理者中是否有指定名称函数
        /// 3. 检察此函数参数，与数返回值据类型一致
        /// 4. 利用反射调用函数
        /// 5. 返回值为true,则处理结束
        /// </summary>
        public void Dispatch()
        {
            var paramType = this.GetType();
            var objParams = new object[1];

            objParams[0] = this;

            if ( null == Handlers )
            {
                return;
            }

            foreach(var handler in Handlers)
            {
                if ( null == handler )
                {
                    continue;
                }

                // 获取参数类型
                var instType     = handler.GetType();

                do
                {
                    var instMthInfos = instType.GetMethods( BindingFlags.Instance       |
                                                            BindingFlags.DeclaredOnly   |
                                                            BindingFlags.Public         |
                                                            BindingFlags.NonPublic
                                                            );
                    var findsMthInfos = FindMethods(instMthInfos, paramType.Name);

                    foreach (var item in findsMthInfos)
                    {
                        var mth = (MethodInfo)item;

                        // 调用对应实例方法
                        var ret = (bool)mth.Invoke(handler, objParams);
                        if (ret)
                        {
                            return;
                        }
                    }

                    instType = instType.BaseType;

                } while (instType != null);

            }

        }

        private Array FindMethods(MethodInfo[] mthInfos, string paramType)
        {
            var findMethods = new ArrayList();

            foreach (var instMth in mthInfos)
            {
                var paramInfos = instMth.GetParameters();

                // 防止调用父类函数
                //if ( instType != instMth.DeclaringType )
                //{
                //    continue;
                //}

                // 参数个数检查
                if (paramInfos.Length != 1)
                {
                    continue;
                }

                // 方法必须是指定名称
                if (DFT_HANDLE_METHOD_NAME.CompareTo(instMth.Name) != 0)
                {
                    continue;
                }

                // 参数类型检查
                if (paramInfos[0].ParameterType.Name.CompareTo(paramType) != 0)
                {
                    continue;
                }

                // 方法返回值检察
                if (instMth.ReturnType.Name.CompareTo(typeof(bool).Name) != 0)
                {
                    continue;
                }

                findMethods.Add(instMth);
            }

            return findMethods.ToArray();
        }

        #endregion 
    }
}