using LeanCloud;
using LeanCloud.Storage.Internal;
using LeanCloud.Realtime.Internal;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace LeanCloud.Realtime
{
    /// <summary>
    /// 代表一个实时通信的终端用户
    /// </summary>
    public class AVIMClient
    {
        private readonly string clientId;
        private readonly AVRealtime _realtime;
        internal readonly object mutex = new object();
        internal readonly object patchMutex = new object();

        /// <summary>
        /// 一些可变的配置选项，便于应对各种需求场景
        /// </summary>
        public struct Configuration
        {
            /// <summary>
            /// Gets or sets a value indicating whether this <see cref="T:LeanCloud.Realtime.AVIMClient.Configuration"/>
            /// auto read.
            /// </summary>
            /// <value><c>true</c> if auto read; otherwise, <c>false</c>.</value>
            public bool AutoRead { get; set; }
        }

        /// <summary>
        /// Gets or sets the current configuration.
        /// </summary>
        /// <value>The current configuration.</value>
        public Configuration CurrentConfiguration
        {
            get; set;
        }

        internal AVRealtime LinkedRealtime
        {
            get { return _realtime; }
        }

        /// <summary>
        /// 单点登录所使用的 Tag
        /// </summary>
        public string Tag
        {
            get;
            private set;
        }

        /// <summary>
        /// 客户端的标识,在一个 Application 内唯一。
        /// </summary>
        public string ClientId
        {
            get { return clientId; }
        }

        //private EventHandler<AVIMNotice> m_OnNoticeReceived;
        ///// <summary>
        ///// 接收到服务器的命令时触发的事件
        ///// </summary>
        //public event EventHandler<AVIMNotice> OnNoticeReceived
        //{
        //    add
        //    {
        //        m_OnNoticeReceived += value;
        //    }
        //    remove
        //    {
        //        m_OnNoticeReceived -= value;
        //    }
        //}

        private int onMessageReceivedCount = 0;
        private EventHandler<AVIMMessageEventArgs> m_OnMessageReceived;
        /// <summary>
        /// 接收到聊天消息的事件通知
        /// </summary>
        public event EventHandler<AVIMMessageEventArgs> OnMessageReceived
        {
            add
            {
                onMessageReceivedCount++;
                AVRealtime.PrintLog("AVIMClient.OnMessageReceived event add with " + onMessageReceivedCount + " times");
                m_OnMessageReceived += value;
            }
            remove
            {
                onMessageReceivedCount--;
                AVRealtime.PrintLog("AVIMClient.OnMessageReceived event remove with" + onMessageReceivedCount + " times");
                m_OnMessageReceived -= value;
            }
        }

        /// <summary>
        /// Occurs when on members joined.
        /// </summary>
        public event EventHandler<AVIMOnMembersJoinedEventArgs> OnMembersJoined;

        /// <summary>
        /// Occurs when on members left.
        /// </summary>
        public event EventHandler<AVIMOnMembersLeftEventArgs> OnMembersLeft;

        /// <summary>
        /// Occurs when on kicked.
        /// </summary>
        public event EventHandler<AVIMOnKickedEventArgs> OnKicked;

        /// <summary>
        /// Occurs when on invited.
        /// </summary>
        public event EventHandler<AVIMOnInvitedEventArgs> OnInvited;

        internal event EventHandler<AVIMMessageEventArgs> OnOfflineMessageReceived;

        private EventHandler<AVIMSessionClosedEventArgs> m_OnSessionClosed;
        /// <summary>
        /// 当前打开的链接被迫关闭时触发的事件回调
        /// <remarks>可能的原因有单点登录冲突，或者被 REST API 强制踢下线</remarks>
        /// </summary>
        public event EventHandler<AVIMSessionClosedEventArgs> OnSessionClosed
        {
            add
            {
                m_OnSessionClosed += value;
            }
            remove
            {
                m_OnSessionClosed -= value;
            }
        }

        /// <summary>
        /// 创建 AVIMClient 对象
        /// </summary>
        /// <param name="clientId"></param>
        /// <param name="realtime"></param>
        internal AVIMClient(string clientId, AVRealtime realtime)
            : this(clientId, null, realtime)
        {

        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="clientId"></param>
        /// <param name="tag"></param>
        /// <param name="realtime"></param>
        internal AVIMClient(string clientId, string tag, AVRealtime realtime)
        {
            this.clientId = clientId;
            Tag = tag ?? tag;
            _realtime = realtime;

            #region sdk 强制在接收到消息之后一定要向服务端回发 ack
            var ackListener = new AVIMMessageListener();
            ackListener.OnMessageReceived += AckListener_OnMessageReceieved;
            //this.RegisterListener(ackListener);
            #endregion

            #region 默认要为当前 client 绑定一个消息的监听器，用作消息的事件通知
            var messageListener = new AVIMMessageListener();
            messageListener.OnMessageReceived += MessageListener_OnMessageReceived;
            this.RegisterListener(messageListener);
            #endregion

            #region 默认要为当前 client 绑定一个 session close 的监听器，用来监测单点登录冲突的事件通知
            var sessionListener = new SessionListener();
            sessionListener.OnSessionClosed += SessionListener_OnSessionClosed;
            this.RegisterListener(sessionListener);
            #endregion

            #region 默认要为当前 client 监听 Ta 所出的对话中的人员变动的被动消息通知
            var membersJoinedListener = new AVIMMembersJoinListener();
            membersJoinedListener.OnMembersJoined += MembersJoinedListener_OnMembersJoined;
            this.RegisterListener(membersJoinedListener);

            var membersLeftListener = new AVIMMembersLeftListener();
            membersLeftListener.OnMembersLeft += MembersLeftListener_OnMembersLeft;
            this.RegisterListener(membersLeftListener);

            var invitedListener = new AVIMInvitedListener();
            invitedListener.OnInvited += InvitedListener_OnInvited;
            this.RegisterListener(invitedListener);

            var kickedListener = new AVIMKickedListener();
            kickedListener.OnKicked += KickedListener_OnKicked;
            this.RegisterListener(kickedListener);
            #endregion

            #region 当前 client id 离线的时间内，TA 所在的对话产生的普通消息会以离线消息的方式送达到 TA 下一次登录的客户端
            var offlineMessageListener = new OfflineMessageListener();
            offlineMessageListener.OnOfflineMessageReceived += OfflineMessageListener_OnOfflineMessageReceived;
            this.RegisterListener(offlineMessageListener);
            #endregion

            #region 当前 client 离线期间内产生的未读消息可以通过之后调用 Conversation.SyncStateAsync 获取一下离线期间内的未读状态
            var unreadListener = new ConversationUnreadListener();
            this.RegisterListener(unreadListener);
            #endregion

            #region 消息补丁（修改或者撤回）
            var messagePatchListener = new MessagePatchListener();
            messagePatchListener.OnReceived = (messages) =>
            {
                foreach (var message in messages) {
                    if (message is AVIMRecalledMessage) {
                        m_OnMessageRecalled?.Invoke(this, new AVIMMessagePatchEventArgs(message));
                    } else {
                        m_OnMessageUpdated?.Invoke(this, new AVIMMessagePatchEventArgs(message));
                    }
                }
            };
            this.RegisterListener(messagePatchListener);
            #endregion

            #region configuration
            CurrentConfiguration = new Configuration()
            {
                AutoRead = true,
            };
            #endregion

        }

        private void OfflineMessageListener_OnOfflineMessageReceived(object sender, AVIMMessageEventArgs e)
        {
            if (OnOfflineMessageReceived != null)
            {
                OnOfflineMessageReceived(this, e);
            }
            this.AckListener_OnMessageReceieved(sender, e);
        }

        private void KickedListener_OnKicked(object sender, AVIMOnKickedEventArgs e)
        {
            if (OnKicked != null)
                OnKicked(this, e);
        }

        private void InvitedListener_OnInvited(object sender, AVIMOnInvitedEventArgs e)
        {
            if (OnInvited != null)
                OnInvited(this, e);
        }

        private void MembersLeftListener_OnMembersLeft(object sender, AVIMOnMembersLeftEventArgs e)
        {
            if (OnMembersLeft != null)
                OnMembersLeft(this, e);
        }

        private void MembersJoinedListener_OnMembersJoined(object sender, AVIMOnMembersJoinedEventArgs e)
        {
            if (OnMembersJoined != null)
                OnMembersJoined(this, e);
        }

        private void SessionListener_OnSessionClosed(int arg1, string arg2, string arg3)
        {
            if (m_OnSessionClosed != null)
            {
                var args = new AVIMSessionClosedEventArgs()
                {
                    Code = arg1,
                    Reason = arg2,
                    Detail = arg3
                };
                if (args.Code == 4115 || args.Code == 4111)
                {
                    this._realtime.sessionConflict = true;
                }

                m_OnSessionClosed(this, args);
            }
            AVRealtime.PrintLog("SessionListener_OnSessionClosed invoked.");
            //this.LinkedRealtime.LogOut();
        }

        private void MessageListener_OnMessageReceived(object sender, AVIMMessageEventArgs e)
        {
            if (this.m_OnMessageReceived != null)
            {
                this.m_OnMessageReceived.Invoke(this, e);
            }
            this.AckListener_OnMessageReceieved(sender, e);
        }

        private void AckListener_OnMessageReceieved(object sender, AVIMMessageEventArgs e)
        {
            lock (mutex)
            {
                var ackCommand = new AckCommand().MessageId(e.Message.Id)
                    .ConversationId(e.Message.ConversationId);

                // 在 v.2 协议下，只要在线收到消息，就默认是已读的，下次上线不会再把当前消息当做未读消息
                if (this.LinkedRealtime.CurrentConfiguration.OfflineMessageStrategy == AVRealtime.OfflineMessageStrategy.UnreadNotice)
                {
                    ackCommand = ackCommand.ReadAck();
                }

                this.RunCommandAsync(ackCommand);
            }
        }

        private void UpdateUnreadNotice(object sender, AVIMMessageEventArgs e)
        {
            ConversationUnreadListener.UpdateNotice(e.Message);
        }

        #region listener 

        /// <summary>
        /// 注册 IAVIMListener
        /// </summary>
        /// <param name="listener"></param>
        /// <param name="runtimeHook"></param>
        public void RegisterListener(IAVIMListener listener, Func<AVIMNotice, bool> runtimeHook = null)
        {
            _realtime.SubscribeNoticeReceived(listener, runtimeHook);
        }

        #region get client instance
        /// <summary>
        /// Get the specified clientId.
        /// </summary>
        /// <returns>The get.</returns>
        /// <param name="clientId">Client identifier.</param>
        public static AVIMClient Get(string clientId)
        {
            if (AVRealtime.clients == null || !AVRealtime.clients.ContainsKey(clientId)) throw new Exception(string.Format("no client found with a id in {0}", clientId));

            return AVRealtime.clients[clientId];
        }
        #endregion

        #endregion
        /// <summary>
        /// 创建对话
        /// </summary>
        /// <param name="conversation">对话</param>
        /// <param name="isUnique">是否创建唯一对话，当 isUnique 为 true 时，如果当前已经有相同成员的对话存在则返回该对话，否则会创建新的对话。该值默认为 false。</param>
        /// <returns></returns>
        internal Task<AVIMConversation> CreateConversationAsync(AVIMConversation conversation, bool isUnique = true)
        {
            var cmd = new ConversationCommand()
                .Generate(conversation)
                .Unique(isUnique);

            var convCmd = cmd.Option("start")
                .PeerId(clientId);

            return LinkedRealtime.AttachSignature(convCmd, LinkedRealtime.SignatureFactory.CreateStartConversationSignature(this.clientId, conversation.MemberIds)).OnSuccess(_ =>
             {
                 return this.RunCommandAsync(convCmd).OnSuccess(t =>
                  {
                      var result = t.Result;
                      if (result.Item1 < 1)
                      {
                          var members = conversation.MemberIds.ToList();
                          members.Add(ClientId);
                          conversation.MemberIds = members;
                          conversation.MergeFromPushServer(result.Item2);
                      }

                      return conversation;
                  });
             }).Unwrap();
        }

        /// <summary>
        /// 创建与目标成员的对话.
        /// </summary>
        /// <returns>返回对话实例.</returns>
        /// <param name="member">目标成员.</param>
        /// <param name="members">目标成员列表.</param>
        /// <param name="name">对话名称.</param>
        /// <param name="isSystem">是否是系统对话.</param>
        /// <param name="isTransient">是否为暂态对话（聊天室）.</param>
        /// <param name="isUnique">是否是唯一对话.</param>
        /// <param name="options">自定义属性.</param>
        public Task<AVIMConversation> CreateConversationAsync(string member = null,
            IEnumerable<string> members = null,
            string name = "",
            bool isSystem = false,
            bool isTransient = false,
            bool isUnique = true,
            bool isTemporary = false,
            int ttl = 86400,
            IDictionary<string, object> options = null)
        {
            if (member == null) member = ClientId;
            var membersAsList = Concat<string>(member, members, "创建对话时被操作的 member(s) 不可以为空。");
            var conversation = new AVIMConversation(members: membersAsList,
                name: name,
                isUnique: isUnique,
                isSystem: isSystem,
                isTransient: isTransient, 
                isTemporary: isTemporary,
                ttl: ttl,
                client: this);
            if (options != null)
            {
                foreach (var key in options.Keys)
                {
                    conversation[key] = options[key];
                }
            }
            return CreateConversationAsync(conversation, isUnique);
        }

        /// <summary>
        /// Creates the conversation async.
        /// </summary>
        /// <returns>The conversation async.</returns>
        /// <param name="builder">Builder.</param>
        public Task<AVIMConversation> CreateConversationAsync(IAVIMConversatioBuilder builder)
        {
            var conversation = builder.Build();
            return CreateConversationAsync(conversation, conversation.IsUnique);
        }

        /// <summary>
        /// Gets the conversatio builder.
        /// </summary>
        /// <returns>The conversatio builder.</returns>
        public AVIMConversationBuilder GetConversationBuilder()
        {
            var builder = AVIMConversationBuilder.CreateDefaultBuilder();
            builder.Client = this;
            return builder;
        }

        /// <summary>
        /// 创建虚拟对话，对话 id 是由本地直接生成，云端根据规则消息发送给指定的 client id(s)
        /// </summary>
        /// <param name="member"></param>
        /// <param name="members"></param>
        /// <param name="ttl">过期时间，默认是一天(86400 秒)，单位是秒</param>
        /// <returns></returns>
        public Task<AVIMConversation> CreateTemporaryConversationAsync(string member = null,
            IEnumerable<string> members = null, int ttl = 86400)
        {
            if (member == null) member = ClientId;
            var membersAsList = Concat<string>(member, members, "创建对话时被操作的 member(s) 不可以为空。");
            return CreateConversationAsync(member, membersAsList, isTemporary: true, ttl: ttl);
        }

        /// <summary>
        /// 创建聊天室（即：暂态对话）
        /// </summary>
        /// <param name="chatroomName">聊天室名称</param>
        /// <returns></returns>
        public Task<AVIMConversation> CreateChatRoomAsync(string chatroomName)
        {
            return CreateConversationAsync(name: chatroomName, isTransient: true);
        }

        /// <summary>
        /// 获取一个对话
        /// </summary>
        /// <param name="id">对话的 ID</param>
        /// <param name="noCache">从服务器获取</param>
        /// <returns></returns>
        public Task<AVIMConversation> GetConversationAsync(string id, bool noCache = true)
        {
            if (!noCache) return Task.FromResult(new AVIMConversation(this) { ConversationId = id });
            else
            {
                return this.GetQuery().WhereEqualTo("objectId", id).FirstAsync();
            }
        }

        #region send message
        /// <summary>
        /// 向目标对话发送消息
        /// </summary>
        /// <param name="conversation">目标对话</param>
        /// <param name="message">消息体</param>
        /// <returns></returns>
		public Task<IAVIMMessage> SendMessageAsync(
          AVIMConversation conversation,
          IAVIMMessage message)
        {
            return this.SendMessageAsync(conversation, message, new AVIMSendOptions()
            {
                Receipt = true,
                Transient = false,
                Priority = 1,
                Will = false,
                PushData = null,
            });
        }

        /// <summary>
        /// 向目标对话发送消息
        /// </summary>
        /// <param name="conversation">目标对话</param>
        /// <param name="message">消息体</param>
        /// <param name="options">消息的发送选项，包含了一些特殊的标记<see cref="AVIMSendOptions"/></param>
        /// <returns></returns>
        public Task<IAVIMMessage> SendMessageAsync(
          AVIMConversation conversation,
          IAVIMMessage message,
          AVIMSendOptions options)
        {
            if (this.LinkedRealtime.State != AVRealtime.Status.Online) throw new Exception("未能连接到服务器，无法发送消息。");

            var messageBody = message.Serialize();

            message.ConversationId = conversation.ConversationId;
            message.FromClientId = this.ClientId;

            var cmd = new MessageCommand()
                .Message(messageBody)
                .ConvId(conversation.ConversationId)
                .Receipt(options.Receipt)
                .Transient(options.Transient)
                .Priority(options.Priority)
                .Will(options.Will)
                .MentionAll(message.MentionAll);

            if (message is AVIMMessage)
            {
                cmd = ((AVIMMessage)message).BeforeSend(cmd);
            }

            if (options.PushData != null)
            {
                cmd = cmd.PushData(options.PushData);
            }

            if (message.MentionList != null)
            {
                cmd = cmd.Mention(message.MentionList);
            }

            var directCmd = cmd.PeerId(this.ClientId);

            return this.RunCommandAsync(directCmd).OnSuccess(t =>
            {
                var response = t.Result.Item2;

                message.Id = response["uid"].ToString();
                message.ServerTimestamp = long.Parse(response["t"].ToString());

                return message;

            });
        }


        #endregion

        #region mute & unmute
        /// <summary>
        /// 当前用户对目标对话进行静音操作
        /// </summary>
        /// <param name="conversation"></param>
        /// <returns></returns>
        public Task MuteConversationAsync(AVIMConversation conversation)
        {
            var convCmd = new ConversationCommand()
                .ConversationId(conversation.ConversationId)
                .Option("mute")
                .PeerId(this.ClientId);

            return this.RunCommandAsync(convCmd);
        }
        /// <summary>
        /// 当前用户对目标对话取消静音，恢复该对话的离线消息推送
        /// </summary>
        /// <param name="conversation"></param>
        /// <returns></returns>
        public Task UnmuteConversationAsync(AVIMConversation conversation)
        {
            var convCmd = new ConversationCommand()
                .ConversationId(conversation.ConversationId)
                .Option("unmute")
                .PeerId(this.ClientId);

            return this.RunCommandAsync(convCmd);
        }
        #endregion

        #region Conversation members operations
        internal Task OperateMembersAsync(AVIMConversation conversation, string action, string member = null, IEnumerable<string> members = null)
        {
            if (string.IsNullOrEmpty(conversation.ConversationId))
            {
                throw new Exception("conversation id 不可以为空。");
            }

            var membersAsList = Concat<string>(member, members, "加人或者踢人的时候，被操作的 member(s) 不可以为空。");

            var cmd = new ConversationCommand().ConversationId(conversation.ConversationId)
                .Members(membersAsList)
                .Option(action)
                .PeerId(clientId);

            return this.LinkedRealtime.AttachSignature(cmd, LinkedRealtime.SignatureFactory.CreateConversationSignature(conversation.ConversationId, ClientId, membersAsList, ConversationSignatureAction.Add)).OnSuccess(_ =>
            {
                return this.RunCommandAsync(cmd).OnSuccess(t =>
                {
                    var result = t.Result;
                    if (!conversation.IsTransient)
                    {
                        if (conversation.MemberIds == null) conversation.MemberIds = new List<string>();
                        conversation.MemberIds = conversation.MemberIds.Concat(membersAsList);
                    }
                    return result;
                });
            }).Unwrap();
        }
        internal IEnumerable<T> Concat<T>(T single, IEnumerable<T> collection, string exString = null)
        {
            List<T> asList = null;
            if (collection == null)
            {
                collection = new List<T>();
            }
            asList = collection.ToList();
            if (asList.Count == 0 && single == null)
            {
                exString = exString ?? "can not cancat a collection with a null value.";
                throw new ArgumentNullException(exString);
            }
            asList.Add(single);
            return asList;
        }

        #region Join
        /// <summary>
        /// 当前用户加入到目标的对话中
        /// </summary>
        /// <param name="conversation">目标对话</param>
        /// <returns></returns>
        public Task JoinAsync(AVIMConversation conversation)
        {
            return this.OperateMembersAsync(conversation, "add", this.ClientId);
        }
        #endregion

        #region Invite
        /// <summary>
        /// 直接将其他人加入到目标对话
        /// <remarks>被操作的人会在客户端会触发 OnInvited 事件,而已经存在于对话的用户会触发 OnMembersJoined 事件</remarks>
        /// </summary>
        /// <param name="conversation">目标对话</param>
        /// <param name="member">单个的 Client Id</param>
        /// <param name="members">Client Id 集合</param>
        /// <returns></returns>
        public Task InviteAsync(AVIMConversation conversation, string member = null, IEnumerable<string> members = null)
        {
            return this.OperateMembersAsync(conversation, "add", member, members);
        }
        #endregion

        #region Left
        /// <summary>
        /// 当前 Client 离开目标对话
        /// <remarks>可以理解为是 QQ 群的退群操作</remarks>
        /// <remarks></remarks>
        /// </summary>
        /// <param name="conversation">目标对话</param>
        /// <returns></returns>
        [Obsolete("use LeaveAsync instead.")]
        public Task LeftAsync(AVIMConversation conversation)
        {
            return this.OperateMembersAsync(conversation, "remove", this.ClientId);
        }

        /// <summary>
        /// Leaves the conversation async.
        /// </summary>
        /// <returns>The async.</returns>
        /// <param name="conversation">Conversation.</param>
        public Task LeaveAsync(AVIMConversation conversation)
        {
            return this.OperateMembersAsync(conversation, "remove", this.ClientId);
        }
        #endregion

        #region Kick
        /// <summary>
        /// 从目标对话中剔除成员
        /// </summary>
        /// <param name="conversation">目标对话</param>
        /// <param name="member">被剔除的单个成员</param>
        /// <param name="members">被剔除的成员列表</param>
        /// <returns></returns>
        public Task KickAsync(AVIMConversation conversation, string member = null, IEnumerable<string> members = null)
        {
            return this.OperateMembersAsync(conversation, "remove", member, members);
        }
        #endregion

        #endregion

        #region Query && Message history && ack

        /// <summary>
        /// Get conversation query.
        /// </summary>
        /// <returns></returns>
        public AVIMConversationQuery GetQuery()
        {
            return GetConversationQuery();
        }

        /// <summary>
        /// Get conversation query.
        /// </summary>
        /// <returns>The conversation query.</returns>
        public AVIMConversationQuery GetConversationQuery()
        {
            return new AVIMConversationQuery(this);
        }

        #region load message history

        /// <summary>
        /// 查询目标对话的历史消息
        /// <remarks>不支持聊天室（暂态对话）</remarks>
        /// </summary>
        /// <param name="conversation">目标对话</param>
        /// <param name="beforeMessageId">从 beforeMessageId 开始向前查询（和 beforeTimeStampPoint 共同使用，为防止某毫秒时刻有重复消息）</param>
        /// <param name="afterMessageId"> 截止到某个 afterMessageId (不包含)</param>
        /// <param name="beforeTimeStampPoint">从 beforeTimeStampPoint 开始向前查询</param>
        /// <param name="afterTimeStampPoint">拉取截止到 afterTimeStampPoint 时间戳（不包含）</param>
        /// <param name="direction">查询方向，默认是 1，如果是 1 表示从新消息往旧消息方向， 0 则相反,其他值无效</param>
        /// <param name="limit">拉取消息条数，默认值 20 条，可设置为 1 - 1000 之间的任意整数</param>
        /// <returns></returns>
        public Task<IEnumerable<T>> QueryMessageAsync<T>(AVIMConversation conversation,
            string beforeMessageId = null,
            string afterMessageId = null,
            DateTime? beforeTimeStampPoint = null,
            DateTime? afterTimeStampPoint = null,
            int direction = 1,
            int limit = 20)
            where T : IAVIMMessage
        {
            var maxLimit = 1000;
            var actualLimit = limit > maxLimit ? maxLimit : limit;
            var logsCmd = new AVIMCommand()
                .Command("logs")
                .Argument("cid", conversation.ConversationId)
                .Argument("l", actualLimit);

            if (beforeMessageId != null)
            {
                logsCmd = logsCmd.Argument("mid", beforeMessageId);
            }

            if (afterMessageId != null)
            {
                logsCmd = logsCmd.Argument("tmid", afterMessageId);
            }

            if (beforeTimeStampPoint != null && beforeTimeStampPoint.Value != DateTime.MinValue)
            {
                logsCmd = logsCmd.Argument("t", beforeTimeStampPoint.Value.ToUnixTimeStamp());
            }

            if (afterTimeStampPoint != null && afterTimeStampPoint.Value != DateTime.MinValue)
            {
                logsCmd = logsCmd.Argument("tt", afterTimeStampPoint.Value.ToUnixTimeStamp());
            }

            if (direction == 0)
            {
                logsCmd = logsCmd.Argument("direction", "NEW");
            }

            var subMessageType = typeof(T);
            var subTypeInteger = subMessageType == typeof(AVIMTypedMessage) ? 0 : FreeStyleMessageClassInfo.GetTypedInteger(subMessageType.GetTypeInfo());

            if (subTypeInteger != 0)
            {
                logsCmd = logsCmd.Argument("lctype", subTypeInteger);
            }

            return this.RunCommandAsync(logsCmd).OnSuccess(t =>
            {
                var rtn = new List<IAVIMMessage>();
                var result = t.Result.Item2;
                var logs = result["logs"] as List<object>;
                if (logs != null)
                {
                    foreach (var log in logs)
                    {
                        var logMap = log as IDictionary<string, object>;
                        if (logMap != null)
                        {
                            var msgStr = logMap["data"].ToString();
                            var messageObj = AVRealtime.FreeStyleMessageClassingController.Instantiate(msgStr, logMap);
                            messageObj.ConversationId = conversation.ConversationId;
                            rtn.Add(messageObj);
                        }
                    }
                }

                conversation.OnMessageLoad(rtn);

                return rtn.AsEnumerable().OfType<T>();
            });
        }
        #endregion


        //public Task MarkAsReadAsync(string conversationId = null, string messageId = null, AVIMConversation conversation = null, AVIMMessage message = null)
        //{
        //    var msgId = messageId != null ? messageId : message.Id;
        //    var convId = conversationId != null ? conversationId : conversation.ConversationId;
        //    if (convId == null && msgId == null) throw new ArgumentNullException("发送已读回执的时候，必须指定 conversation id 或者 message id");
        //    lock (mutex)
        //    {
        //        var ackCommand = new AckCommand()
        //                .ReadAck().MessageId(msgId)
        //            .ConversationId(convId)
        //            .PeerId(this.ClientId);

        //        return this.RunCommandAsync(ackCommand);
        //    }
        //}
        #region 查询对话中对方的接收状态，也就是已读回执
        private Task<Tuple<long, long>> FetchAllReceiptTimestampsAsync(string targetClientId = null, string conversationId = null, AVIMConversation conversation = null, bool queryAllMembers = false)
        {
            var convId = conversationId != null ? conversationId : conversation.ConversationId;
            if (convId == null) throw new ArgumentNullException("conversationId 和 conversation 不可以同时为 null");

            var cmd = new ConversationCommand().ConversationId(convId)
              .TargetClientId(targetClientId)
              .QueryAllMembers(queryAllMembers)
              .Option("max-read")
              .PeerId(clientId);

            return this.RunCommandAsync(cmd).OnSuccess(t =>
            {
                var result = t.Result;
                long maxReadTimestamp = -1;
                long maxAckTimestamp = -1;

                if (result.Item2.ContainsKey("maxReadTimestamp"))
                {
                    long.TryParse(result.Item2["maxReadTimestamp"].ToString(), out maxReadTimestamp);
                }
                if (result.Item2.ContainsKey("maxAckTimestamp"))
                {
                    long.TryParse(result.Item2["maxAckTimestamp"].ToString(), out maxAckTimestamp);
                }
                return new Tuple<long, long>(maxAckTimestamp, maxReadTimestamp);

            });
        }
        #endregion

        #region 查询对方是否在线
        /// <summary>
        /// 查询对方 client Id 是否在线
        /// </summary>
        /// <param name="targetClientId">单个 client Id</param>
        /// <param name="targetClientIds">多个 client Id 集合</param>
        /// <returns></returns>
        public Task<IEnumerable<Tuple<string, bool>>> PingAsync(string targetClientId = null, IEnumerable<string> targetClientIds = null)
        {
            List<string> queryIds = null;
            if (targetClientIds != null) queryIds = targetClientIds.ToList();
            if (queryIds == null && string.IsNullOrEmpty(targetClientId)) throw new ArgumentNullException("必须查询至少一个 client id 的状态，targetClientId 和 targetClientIds 不可以同时为空");
            queryIds.Add(targetClientId);

            var cmd = new SessionCommand()
                .SessionPeerIds(queryIds)
                .Option("query");

            return this.RunCommandAsync(cmd).OnSuccess(t =>
            {
                var result = t.Result;
                List<Tuple<string, bool>> rtn = new List<Tuple<string, bool>>();
                var onlineSessionPeerIds = AVDecoder.Instance.DecodeList<string>(result.Item2["onlineSessionPeerIds"]);
                foreach (var peerId in targetClientIds)
                {
                    rtn.Add(new Tuple<string, bool>(peerId, onlineSessionPeerIds.Contains(peerId)));
                }
                return rtn.AsEnumerable();
            });
        }
        #endregion
        #region 获取暂态对话在线人数
        /// <summary>
        /// 获取暂态对话（聊天室）在线人数，依赖缓存，并不一定 100% 与真实数据一致。
        /// </summary>
        /// <param name="chatroomId"></param>
        /// <returns></returns>
        public Task<int> CountOnlineClientsAsync(string chatroomId)
        {
            var command = new AVCommand(relativeUri: "rtm/transient_group/onlines?gid=" + chatroomId, method: "GET",
                sessionToken: null,
                headers: null,
                data: null);

            return AVPlugins.Instance.CommandRunner.RunCommandAsync(command).OnSuccess(t =>
               {
                   var result = t.Result.Item2;
                   if (result.ContainsKey("result"))
                   {
                       return int.Parse(result["result"].ToString());
                   }
                   return -1;
               });
        }
        #endregion
        #endregion

        #region mark as read

        /// <summary>
        /// 
        /// </summary>
        /// <param name="conversation"></param>
        /// <param name="message"></param>
        /// <param name="readAt"></param>
        /// <returns></returns>
        public Task ReadAsync(AVIMConversation conversation, IAVIMMessage message = null, DateTime? readAt = null)
        {
            var convRead = new ReadCommand.ConvRead()
            {
                ConvId = conversation.ConversationId,
            };

            if (message != null)
            {
                convRead.MessageId = message.Id;
                convRead.Timestamp = message.ServerTimestamp;
            }

            if (readAt != null && readAt.Value != DateTime.MinValue)
            {
                convRead.Timestamp = readAt.Value.ToUnixTimeStamp();
            }

            var readCmd = new ReadCommand().Conv(convRead).PeerId(this.ClientId);

            this.RunCommandAsync(readCmd);

            return Task.FromResult(true);
        }

        /// <summary>
        /// mark the conversation as read with conversation id.
        /// </summary>
        /// <param name="conversationId">conversation id</param>
        /// <returns></returns>
        public Task ReadAsync(string conversationId)
        {
            var conv = AVIMConversation.CreateWithoutData(conversationId, this);
            return this.ReadAsync(conv);
        }

        /// <summary>
        /// mark all conversations as read.
        /// </summary>
        /// <returns></returns>
        public Task ReadAllAsync()
        {
            var cids = ConversationUnreadListener.FindAllConvIds();
            var readCmd = new ReadCommand().ConvIds(cids).PeerId(this.ClientId);
            return this.RunCommandAsync(readCmd);
        }
        #endregion

        #region recall & modify

        /// <summary>
        /// Recalls the async.
        /// </summary>
        /// <returns>The async.</returns>
        /// <param name="message">Message.</param>
        public Task<AVIMRecalledMessage> RecallAsync(IAVIMMessage message)
        {
            var tcs = new TaskCompletionSource<AVIMRecalledMessage>();
            var patchCmd = new PatchCommand().Recall(message);
            RunCommandAsync(patchCmd)
                .OnSuccess(t => {
                    var recalledMsg = new AVIMRecalledMessage();
                    AVIMMessage.CopyMetaData(message, recalledMsg);
                    tcs.SetResult(recalledMsg);
                });
            return tcs.Task;
        }

        /// <summary>
        /// Modifies the aysnc.
        /// </summary>
        /// <returns>The aysnc.</returns>
        /// <param name="oldMessage">要修改的消息对象</param>
        /// <param name="newMessage">新的消息对象</param>
        public Task<IAVIMMessage> UpdateAsync(IAVIMMessage oldMessage, IAVIMMessage newMessage)
        {
            var tcs = new TaskCompletionSource<IAVIMMessage>();
            var patchCmd = new PatchCommand().Modify(oldMessage, newMessage);
            this.RunCommandAsync(patchCmd)
                .OnSuccess(t => {
                    // 从旧消息对象中拷贝数据
                    AVIMMessage.CopyMetaData(oldMessage, newMessage);
                    // 获取更新时间戳
                    var response = t.Result.Item2;
                    if (response.TryGetValue("lastPatchTime", out object updatedAtObj) && 
                        long.TryParse(updatedAtObj.ToString(), out long updatedAt)) {
                        newMessage.UpdatedAt = updatedAt;
                    }
                    tcs.SetResult(newMessage);
                });
            return tcs.Task;
        }

        internal EventHandler<AVIMMessagePatchEventArgs> m_OnMessageRecalled;
        /// <summary>
        /// Occurs when on message recalled.
        /// </summary>
        public event EventHandler<AVIMMessagePatchEventArgs> OnMessageRecalled
        {
            add
            {
                this.m_OnMessageRecalled += value;
            }
            remove
            {
                this.m_OnMessageRecalled -= value;
            }
        }
        internal EventHandler<AVIMMessagePatchEventArgs> m_OnMessageUpdated;
        /// <summary>
        /// Occurs when on message modified.
        /// </summary>
        public event EventHandler<AVIMMessagePatchEventArgs> OnMessageUpdated
        {
            add
            {
                this.m_OnMessageUpdated += value;
            }
            remove
            {
                this.m_OnMessageUpdated -= value;
            }
        }

        #endregion

        #region log out
        /// <summary>
        /// 退出登录或者切换账号
        /// </summary>
        /// <returns></returns>
        public Task CloseAsync()
        {
            var cmd = new SessionCommand().Option("close");
            return this.RunCommandAsync(cmd).ContinueWith(t =>
            {
                m_OnSessionClosed(this, null);
            });
        }
        #endregion

        /// <summary>
        /// Run command async.
        /// </summary>
        /// <returns>The command async.</returns>
        /// <param name="command">Command.</param>
        public Task<Tuple<int, IDictionary<string, object>>> RunCommandAsync(AVIMCommand command)
        {
            command.PeerId(this.ClientId);
            return this.LinkedRealtime.RunCommandAsync(command);
        }

        /// <summary>
        /// Run command.
        /// </summary>
        /// <param name="command">Command.</param>
        public void RunCommand(AVIMCommand command)
        {
            command.PeerId(this.ClientId);
            this.LinkedRealtime.RunCommand(command);
        }
    }

    /// <summary>
    /// AVIMClient extensions.
    /// </summary>
    public static class AVIMClientExtensions
    {
        /// <summary>
        /// Create conversation async.
        /// </summary>
        /// <returns>The conversation async.</returns>
        /// <param name="client">Client.</param>
        /// <param name="members">Members.</param>
        public static Task<AVIMConversation> CreateConversationAsync(this AVIMClient client, IEnumerable<string> members)
        {
            return client.CreateConversationAsync(members: members);
        }

        public static Task<AVIMConversation> CreateConversationAsync(this AVIMClient client, IEnumerable<string> members, string conversationName)
        {
            return client.CreateConversationAsync(members: members, name: conversationName);
        }

        /// <summary>
        /// Get conversation.
        /// </summary>
        /// <returns>The conversation.</returns>
        /// <param name="client">Client.</param>
        /// <param name="conversationId">Conversation identifier.</param>
        public static AVIMConversation GetConversation(this AVIMClient client, string conversationId)
        {
            return AVIMConversation.CreateWithoutData(conversationId, client);
        }

        /// <summary>
        /// Join conversation async.
        /// </summary>
        /// <returns>The async.</returns>
        /// <param name="client">Client.</param>
        /// <param name="conversationId">Conversation identifier.</param>
        public static Task JoinAsync(this AVIMClient client, string conversationId)
        {
            var conversation = client.GetConversation(conversationId);
            return client.JoinAsync(conversation);
        }

        /// <summary>
        /// Leave conversation async.
        /// </summary>
        /// <returns>The async.</returns>
        /// <param name="client">Client.</param>
        /// <param name="conversationId">Conversation identifier.</param>
        public static Task LeaveAsync(this AVIMClient client, string conversationId)
        {
            var conversation = client.GetConversation(conversationId);
            return client.LeaveAsync(conversation);
        }

        /// <summary>
        /// Query messages.
        /// </summary>
        /// <returns>The message async.</returns>
        /// <param name="client">Client.</param>
        /// <param name="conversation">Conversation.</param>
        /// <param name="beforeMessageId">Before message identifier.</param>
        /// <param name="afterMessageId">After message identifier.</param>
        /// <param name="beforeTimeStampPoint">Before time stamp point.</param>
        /// <param name="afterTimeStampPoint">After time stamp point.</param>
        /// <param name="direction">Direction.</param>
        /// <param name="limit">Limit.</param>
        public static Task<IEnumerable<IAVIMMessage>> QueryMessageAsync(this AVIMClient client,
                                                                        AVIMConversation conversation,
                                                                        string beforeMessageId = null,
                                                                        string afterMessageId = null,
                                                                        DateTime? beforeTimeStampPoint = null,
                                                                        DateTime? afterTimeStampPoint = null,
                                                                        int direction = 1,
                                                                        int limit = 20)
        {
            return client.QueryMessageAsync<IAVIMMessage>(conversation,
                                                         beforeMessageId,
                                                         afterMessageId,
                                                         beforeTimeStampPoint,
                                                         afterTimeStampPoint,
                                                         direction,
                                                          limit);
        }

        /// <summary>
        /// Get the chat room query.
        /// </summary>
        /// <returns>The chat room query.</returns>
        /// <param name="client">Client.</param>
        public static AVIMConversationQuery GetChatRoomQuery(this AVIMClient client)
        {
            return client.GetQuery().WhereEqualTo("tr", true);
        }
    }
}