public void NotifyNewArrival(TwitterStatus status, NotificationType type, string explicitSoundSource)
 {
     if (!_proxy.NotifyNewArrival(status, type, explicitSoundSource))
     {
         Next?.NotifyNewArrival(status, type, explicitSoundSource);
     }
 }

 public static void RegisterStatus(TwitterStatus status)
 {
     status.Entities
         .Where(e => e.EntityType == EntityType.Hashtags)
         .Select(e => e.DisplayText)
         .ForEach(RegisterHashtag);
 }

 public void NotifyUnfavorited(TwitterUser source, TwitterStatus status)
 {
     if (!_proxy.NotifyUnfavorited(source, status) && this.Next != null)
     {
         this.Next.NotifyUnfavorited(source, status);
     }
 }

 public void NotifyReceived(TwitterStatus status)
 {
     if (!_proxy.NotifyReceived(status) && this.Next != null)
     {
         this.Next.NotifyReceived(status);
     }
 }

 public void NotifyNewArrival(TwitterStatus status, NotificationType type, string explicitSoundSource)
 {
     if (!_proxy.NotifyNewArrival(status, type, explicitSoundSource) && this.Next != null)
     {
         this.Next.NotifyNewArrival(status, type, explicitSoundSource);
     }
 }

 public virtual void NotifyReceived(TwitterStatus status)
 {
     if (Next != null)
     {
         Next.NotifyReceived(status);
     }
 }

 public void NotifyDeleted(long statusId, TwitterStatus deleted)
 {
     if (Next != null)
     {
         Next.NotifyDeleted(statusId, deleted);
     }
 }

 public void NotifyRetweeted(TwitterUser source, TwitterStatus status)
 {
     if (Next != null)
     {
         Next.NotifyRetweeted(source, status);
     }
 }

 public void NotifyRetweeted(TwitterUser source, TwitterStatus original, TwitterStatus retweet)
 {
     if (!_proxy.NotifyRetweeted(source, original, retweet) && this.Next != null)
     {
         this.Next.NotifyRetweeted(source, original, retweet);
     }
 }

 internal static void StartAcceptNewArrival(TwitterStatus status)
 {
     lock (_acceptingArrivals)
     {
         _acceptingArrivals[status.Id] = new List<TabModel>();
     }
 }

 public void NotifyFavorited(TwitterUser source, TwitterStatus status)
 {
     if (!_proxy.NotifyFavorited(source, status))
     {
         Next?.NotifyFavorited(source, status);
     }
 }

 internal static void EndAcceptNewArrival(TwitterStatus status)
 {
     List<TabModel> removal;
     lock (_acceptingArrivals)
     {
         if (!_acceptingArrivals.TryGetValue(status.Id, out removal) || removal.Count == 0) return;
     }
     var soundSource = removal
         .Select(t => t.NotifySoundSource)
         .Where(s => !String.IsNullOrEmpty(s))
         .Where(File.Exists)
         .FirstOrDefault();
     if (status.StatusType == StatusType.DirectMessage)
     {
         Task.Run(() => NotifyNewArrival(status, NotificationType.DirectMessage, soundSource));
     }
     else if (FilterSystemUtil.InReplyToUsers(status).Intersect(Setting.Accounts.Ids).Any())
     {
         Task.Run(() => NotifyNewArrival(status, NotificationType.Mention, soundSource));
     }
     else
     {
         Task.Run(() => NotifyNewArrival(status, NotificationType.Normal, soundSource));
     }
 }

 public void NotifyRetweeted(TwitterUser source, TwitterStatus status)
 {
     if (_proxy.NotifyRetweeted(source, status) && this.Next != null)
     {
         this.Next.NotifyRetweeted(source, status);
     }
 }

 public TwitterStatus(dynamic json)
 {
     this.GenerateFromJson = true;
     this.Id = ((string)json.id_str).ParseLong();
     this.CreatedAt = ((string)json.created_at).ParseDateTime(ParsingExtension.TwitterDateTimeFormat);
     this.Text = ParsingExtension.ResolveEntity(json.text);
     if (json.extended_entities())
     {
         this.Entities = Enumerable.ToArray(Enumerable.Concat(
             TwitterEntity.GetEntities(json.entities),
             TwitterEntity.GetEntities(json.extended_entities)));
     }
     else if (json.entities())
     {
         this.Entities = Enumerable.ToArray(TwitterEntity.GetEntities(json.entities));
     }
     else
     {
         this.Entities = new TwitterEntity[0];
     }
     if (json.recipient())
     {
         // THIS IS DIRECT MESSAGE!
         this.StatusType = StatusType.DirectMessage;
         this.User = new TwitterUser(json.sender);
         this.Recipient = new TwitterUser(json.recipient);
     }
     else
     {
         this.StatusType = StatusType.Tweet;
         this.User = new TwitterUser(json.user);
         this.Source = json.source;
         if (json.in_reply_to_status_id_str())
         {
             this.InReplyToStatusId = ((string)json.in_reply_to_status_id_str).ParseNullableId();
         }
         if (json.in_reply_to_user_id_str())
         {
             this.InReplyToUserId = ((string)json.in_reply_to_user_id_str).ParseNullableId();
         }
         if (json.in_reply_to_screen_name())
         {
             this.InReplyToScreenName = json.in_reply_to_screen_name;
         }
         if (json.retweeted_status())
         {
             var original = new TwitterStatus(json.retweeted_status);
             this.RetweetedOriginal = original;
             this.RetweetedOriginalId = original.Id;
             // merge text and entities
             this.Text = original.Text;
             this.Entities = original.Entities.Guard().ToArray();
         }
         if (json.coordinates() && json.coordinates != null)
         {
             this.Longitude = (double)json.coordinates.coordinates[0];
             this.Latitude = (double)json.coordinates.coordinates[1];
         }
     }
 }

 public void NotifyReceived(TwitterStatus status)
 {
     if (!_proxy.NotifyReceived(status))
     {
         Next?.NotifyReceived(status);
     }
 }

 public void MessageReceived(TwitterStatus status)
 {
     lock (_urgentPriorityQueue)
     {
         _urgentPriorityQueue.AddLast(new NotificationData(SlimNotificationKind.Message, status));
     }
     OnNewNotificationDataQueued.SafeInvoke();
 }

 public void StatusReceived(TwitterStatus status)
 {
     lock (_lowPriorityQueue)
     {
         _lowPriorityQueue.AddLast(new NotificationData(SlimNotificationKind.New, status));
     }
     OnNewNotificationDataQueued.SafeInvoke();
 }

 public void NotifyRetweeted(TwitterUser source, TwitterStatus original, TwitterStatus retweet)
 {
     if (Setting.Accounts.Contains(source.Id) ||
         Setting.Accounts.Contains(original.User.Id))
     {
         BackstageModel.RegisterEvent(new RetweetedEvent(source, original));
     }
 }

 internal static void NotifyReceived(TwitterStatus status)
 {
     if (status.RetweetedOriginal != null)
     {
         NotifyRetweeted(status.User, status.RetweetedOriginal);
     }
     Head.NotifyReceived(status);
 }

 private bool CheckVisibleTimeline(TwitterStatus status, IEnumerable<TwitterAccount> datas)
 {
     if (status.StatusType == StatusType.DirectMessage)
         return false;
     return datas.Any(account =>
                      status.User.Id == account.Id ||
                      account.RelationData.IsFollowing(status.User.Id) ||
                      FilterSystemUtil.InReplyToUsers(status).Contains(account.Id));
 }