using System;
using System.Collections.Generic;
using System.Diagnostics;

namespace Bro.Common.PubSub
{
    /// <summary>
    /// 简单发布/订阅中心
    /// </summary>
    public class SimplePubSubCenter : IPubSubCenter
    {
        /// <summary>
        /// 订阅主题和订阅者
        /// </summary>
        private Dictionary<string, Subscribers> subMap = new Dictionary<string, Subscribers>();

        /// <summary>
        /// 订阅事件
        /// </summary>
        /// <param name="tag"></param>
        /// <param name="method"></param>
        /// <returns></returns>
        public bool Subscribe(string tag, Func<ISubscriber, object, object, object> method)
        {
            var sub = new SimpleSubscriber();

            // 默认使用hash值设置名称，防止重复
            sub.SubscriberName  = sub.GetHashCode().ToString();
            sub.SubMethod       = method;

            return Subscribe(tag, sub);
        }

        /// <summary>
        /// 订阅事件
        /// </summary>
        /// <param name="tag"></param>
        /// <param name="subscribe"></param>
        /// <returns></returns>
        public bool Subscribe(string tag, ISubscriber subscribe)
        {
            if ( null == tag || null == subscribe )
            {
                return false;
            }
        
            if ( subMap.ContainsKey(tag) )
            {
                var subs = subMap[tag];

                return subs.Add(subscribe);
            }
            else
            {
                var subs = new Subscribers();
                if ( !subs.Add(subscribe) )
                {
                    return false;
                }

                subMap.Add(tag, subs);

                return true;
            }
        }

        /// <summary>
        /// 发布事件
        /// </summary>
        /// <param name="tag"></param>
        /// <param name="data"></param>
        public void Publish(string tag, object param1, object param2)
        {
            if ( null == tag )
            {
                return;
            }

            // 获取所有tag订阅者
            var subs = GetSubscribers(tag);
            if ( null == subs )
            {
                return;
            }

            var enmtor = subs.GetEnumerator();
            if ( null == enmtor )
            {
                return;
            }
            
            // 通知所有订阅者事件
            while(enmtor.MoveNext())
            {
                var cur = enmtor.Current;
                if ( null == cur || null == cur.SubMethod)
                {
                    continue;
                }

                cur.SubMethod(cur, param1, param2);
            }
        }

        /// <summary>
        /// 获取所有订阅者
        /// </summary>
        /// <param name="tag"></param>
        /// <returns></returns>
        public Subscribers GetSubscribers(string tag)
        {
            if ( !subMap.ContainsKey(tag) )
            {
                return null;
            }

            return subMap[tag];
        }

        /// <summary>
        /// 获取某个订阅者
        /// </summary>
        /// <param name="tag"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        public ISubscriber GetSubscriber(string tag, string name)
        {
            var subs = GetSubscribers(tag);
            if ( null == subs )
            {
                return null;
            }

            return subs.GetSubscriber(name);
        }

        /// <summary>
        /// 移除某个订阅者
        /// </summary>
        /// <param name="tag"></param>
        /// <param name="name"></param>
        /// <returns></returns>
        public bool RemoveSubscriber(string tag, string name)
        {
            var subs = GetSubscribers(tag);
            if ( null == subs )
            {
                return false;
            }

            if ( !subs.Rmv(name) )
            {
                return false;
            }

            if ( subs.GetCount() == 0 )
            {
                subMap.Remove(tag);
            }

            return true;
        }

        /// <summary>
        /// 移除订阅
        /// </summary>
        /// <param name="tag"></param>
        /// <param name="method"></param>
        /// <returns></returns>
        public bool RemoveSubscriber(string tag, Func<ISubscriber, object, object, object> method)
        {
            var subs = GetSubscribers(tag);
            if ( null == subs )
            {
                return false;
            }

            if ( !subs.Rmv(method) )
            {
                return false;
            }

            if ( subs.GetCount() == 0 )
            {
                subMap.Remove(tag);
            }

            return true;
        }

        /// <summary>
        /// 移除某类所有订阅者
        /// </summary>
        /// <param name="tag"></param>
        /// <returns></returns>
        public bool RemoveSubscribers(string tag)
        {
            var subs = GetSubscribers(tag);
            if ( null == subs )
            {
                return false;
            }

            subMap.Remove(tag);

            return true;
        }

        //IEnumerable<Object> Publish(string tag, object data);

        //IEnumerable<Object> Publish(string tag);

        //IEnumerable<Object> Publish(IPublisher publisher);
    }

    /// <summary>
    /// 订阅者集合
    /// </summary>
    public class Subscribers
    {
        /// <summary>
        /// 订阅者集合
        /// </summary>
        private Dictionary<string, ISubscriber>     subMap = new Dictionary<string,ISubscriber>();

        /// <summary>
        /// 订阅者集合
        /// </summary>
        private List<ISubscriber>  subList = new List<ISubscriber>();

        public Subscribers()
        {
        
        }

        /// <summary>
        /// 新增订阅者
        /// </summary>
        /// <param name="sub"></param>
        /// <returns></returns>
        public bool Add(ISubscriber sub)
        {
            if ( null == sub || subMap.ContainsKey(sub.SubscriberName) )
            {
                return false;
            }

            subMap.Add(sub.SubscriberName, sub);
            subList.Add(sub);

            return true;
        }

        /// <summary>
        /// 移除订阅者
        /// </summary>
        /// <param name="sub"></param>
        /// <returns></returns>
        public bool Rmv(ISubscriber sub)
        {
            if ( null == sub || !subMap.ContainsKey(sub.SubscriberName) )
            {
                return false;
            }

            subMap.Remove(sub.SubscriberName);
            subList.Remove(sub);

            return true;
        }

        /// <summary>
        /// 移除订阅者
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public bool Rmv(string name)
        {
            if ( !subMap.ContainsKey(name) )
            {
                return false;
            }

            var sub = subMap[name];

            subMap.Remove(name);
            subList.Remove(sub);

            return true;
        }

        /// <summary>
        /// 移除订阅者
        /// </summary>
        /// <param name="method"></param>
        /// <returns></returns>
        public bool Rmv(Func<ISubscriber, object, object, object> method)
        {
            var names   = new List<string>();

            try
            {
                foreach(var item in subMap)
                {
                    if ( null == item.Value )
                    {
                        continue;
                    }

                    // 若是相同函数，则移除
                    if ( item.Value.SubMethod == method )
                    {
                        names.Add(item.Key);
                    }
                }

                for(int i = 0; i < names.Count; i++)
                {
                    subMap.Remove(names[i]);
                }

                names.Clear();

                return true;
            }
            catch(Exception ex)
            {
                Trace.TraceError("Remove subscriber fail,ex:{0}", ex);
            }

            return false;
        }

        /// <summary>
        /// 检察订阅者是否存在
        /// </summary>
        /// <param name="sub"></param>
        /// <returns></returns>
        public bool Contains(ISubscriber sub)
        {
            if ( null == sub || !subMap.ContainsKey(sub.SubscriberName) )
            {
                return false;
            }

            return true;
        }

        /// <summary>
        /// 获取订阅者
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public ISubscriber GetSubscriber(string name)
        {
            if ( !subMap.ContainsKey(name) )
            {
                return null;
            }

            return subMap[name];
        }

        /// <summary>
        /// 清除所有订阅者
        /// </summary>
        public void Clear()
        {
            subMap.Clear();
            subList.Clear();
        }

        /// <summary>
        /// 获取订阅者枚举
        /// </summary>
        /// <returns></returns>
        public IEnumerator<ISubscriber> GetEnumerator()
        {
            return subList.GetEnumerator();
        }

        /// <summary>
        /// 获取订阅者数量
        /// </summary>
        /// <returns></returns>
        public int GetCount()
        {
            return subMap.Count;
        }
    }
}