youys
/
Discord.Net
Not watched
1
0
Fork 0
Code
Releases 34 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 8f87b2cc71
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '8f87b2cc71'
${ noResults }
Discord.Net/src/Discord.Net.WebSocket/DiscordSocketClient.cs

1813 lines
98 KiB
Raw Blame History 

  1. using Discord.API;

  2. using Discord.API.Gateway;

  3. using Discord.Audio;

  4. using Discord.Logging;

  5. using Discord.Net.Converters;

  6. using Discord.Net.Queue;

  7. using Discord.Net.Udp;

  8. using Discord.Net.WebSockets;

  9. using Discord.Rest;

  10. using Newtonsoft.Json;

  11. using Newtonsoft.Json.Linq;

  12. using System;

  13. using System.Collections.Concurrent;

  14. using System.Collections.Generic;

  15. using System.Collections.Immutable;

  16. using System.IO;

  17. using System.Linq;

  18. using System.Threading;

  19. using System.Threading.Tasks;

  20. using GameModel = Discord.API.Game;

  21. 

  22. namespace Discord.WebSocket

  23. {

  24.     public partial class DiscordSocketClient : BaseDiscordClient, IDiscordClient

  25.     {

  26.         private readonly ConcurrentQueue<ulong> _largeGuilds;

  27.         private readonly Logger _gatewayLogger;

  28.         private readonly JsonSerializer _serializer;

  29. 

  30.         private string _sessionId;

  31.         private int _lastSeq;

  32.         private ImmutableDictionary<string, RestVoiceRegion> _voiceRegions;

  33.         private TaskCompletionSource<bool> _connectTask;

  34.         private CancellationTokenSource _cancelToken, _reconnectCancelToken;

  35.         private Task _heartbeatTask, _guildDownloadTask, _reconnectTask;

  36.         private long _heartbeatTime;

  37.         private int _unavailableGuilds;

  38.         private long _lastGuildAvailableTime;

  39.         private int _nextAudioId;

  40.         private bool _canReconnect;

  41.         private DateTimeOffset? _statusSince;

  42.         private RestApplication _applicationInfo;

  43. 

  44.         /// <summary> Gets the shard of of this client. </summary>

  45.         public int ShardId { get; }

  46.         /// <summary> Gets the current connection state of this client. </summary>

  47.         public ConnectionState ConnectionState { get; private set; }

  48.         /// <summary> Gets the estimated round-trip latency, in milliseconds, to the gateway server. </summary>

  49.         public int Latency { get; private set; }

  50.         internal UserStatus Status { get; private set; } = UserStatus.Online;

  51.         internal Game? Game { get; private set; }

  52. 

  53.         //From DiscordSocketConfig

  54.         internal int TotalShards { get; private set; }

  55.         internal int MessageCacheSize { get; private set; }

  56.         internal int LargeThreshold { get; private set; }

  57.         internal AudioMode AudioMode { get; private set; }

  58.         internal ClientState State { get; private set; }

  59.         internal int ConnectionTimeout { get; private set; }

  60.         internal UdpSocketProvider UdpSocketProvider { get; private set; }

  61.         internal WebSocketProvider WebSocketProvider { get; private set; }

  62.         internal bool DownloadUsersOnGuildAvailable { get; private set; }

  63. 

  64.         public new DiscordSocketApiClient ApiClient => base.ApiClient as DiscordSocketApiClient;

  65.         public new SocketSelfUser CurrentUser { get { return base.CurrentUser as SocketSelfUser; } private set { base.CurrentUser = value; } }

  66.         public IReadOnlyCollection<SocketGuild> Guilds => State.Guilds;

  67.         public IReadOnlyCollection<ISocketPrivateChannel> PrivateChannels => State.PrivateChannels;

  68. 

  69.         /// <summary> Creates a new REST/WebSocket discord client. </summary>

  70.         public DiscordSocketClient() : this(new DiscordSocketConfig()) { }

  71.         /// <summary> Creates a new REST/WebSocket discord client. </summary>

  72.         public DiscordSocketClient(DiscordSocketConfig config) : this(config, CreateApiClient(config)) { }

  73.         private DiscordSocketClient(DiscordSocketConfig config, API.DiscordSocketApiClient client)

  74.             : base(config, client)

  75.         {

  76.             ShardId = config.ShardId;

  77.             TotalShards = config.TotalShards;

  78.             MessageCacheSize = config.MessageCacheSize;

  79.             LargeThreshold = config.LargeThreshold;

  80.             AudioMode = config.AudioMode;

  81.             UdpSocketProvider = config.UdpSocketProvider;

  82.             WebSocketProvider = config.WebSocketProvider;

  83.             DownloadUsersOnGuildAvailable = config.DownloadUsersOnGuildAvailable;

  84.             ConnectionTimeout = config.ConnectionTimeout;

  85.             State = new ClientState(0, 0);

  86.             

  87.             _nextAudioId = 1;

  88.             _gatewayLogger = LogManager.CreateLogger("Gateway");

  89. 

  90.             _serializer = new JsonSerializer { ContractResolver = new DiscordContractResolver() };

  91.             _serializer.Error += (s, e) =>

  92.             {

  93.                 _gatewayLogger.WarningAsync(e.ErrorContext.Error).GetAwaiter().GetResult();

  94.                 e.ErrorContext.Handled = true;

  95.             };

  96.             

  97.             ApiClient.SentGatewayMessage += async opCode => await _gatewayLogger.DebugAsync($"Sent {opCode}").ConfigureAwait(false);

  98.             ApiClient.ReceivedGatewayEvent += ProcessMessageAsync;

  99.             ApiClient.Disconnected += async ex =>

  100.             {

  101.                 if (ex != null)

  102.                 {

  103.                     await _gatewayLogger.WarningAsync($"Connection Closed", ex).ConfigureAwait(false);

  104.                     await StartReconnectAsync(ex).ConfigureAwait(false);

  105.                 }

  106.                 else

  107.                     await _gatewayLogger.WarningAsync($"Connection Closed").ConfigureAwait(false);

  108.             };

  109. 

  110.             LeftGuild += async g => await _gatewayLogger.InfoAsync($"Left {g.Name}").ConfigureAwait(false);

  111.             JoinedGuild += async g => await _gatewayLogger.InfoAsync($"Joined {g.Name}").ConfigureAwait(false);

  112.             GuildAvailable += async g => await _gatewayLogger.VerboseAsync($"Connected to {g.Name}").ConfigureAwait(false);

  113.             GuildUnavailable += async g => await _gatewayLogger.VerboseAsync($"Disconnected from {g.Name}").ConfigureAwait(false);

  114.             LatencyUpdated += async (old, val) => await _gatewayLogger.VerboseAsync($"Latency = {val} ms").ConfigureAwait(false);

  115. 

  116.             if (DownloadUsersOnGuildAvailable)

  117.             {

  118.                 GuildAvailable += g =>

  119.                 {

  120.                     var _ = g.DownloadUsersAsync();

  121.                     return Task.Delay(0);

  122.                 };

  123.             }

  124. 

  125.             _voiceRegions = ImmutableDictionary.Create<string, RestVoiceRegion>();

  126.             _largeGuilds = new ConcurrentQueue<ulong>();

  127.         }

  128.         private static API.DiscordSocketApiClient CreateApiClient(DiscordSocketConfig config)

  129.             => new API.DiscordSocketApiClient(config.RestClientProvider, DiscordRestConfig.UserAgent, config.WebSocketProvider, requestQueue: new RequestQueue());

  130.         

  131.         protected override async Task OnLoginAsync(TokenType tokenType, string token)

  132.         {

  133.             var voiceRegions = await ApiClient.GetVoiceRegionsAsync(new RequestOptions { IgnoreState = true}).ConfigureAwait(false);

  134.             _voiceRegions = voiceRegions.Select(x => RestVoiceRegion.Create(this, x)).ToImmutableDictionary(x => x.Id);

  135.         }

  136.         protected override async Task OnLogoutAsync()

  137.         {

  138.             if (ConnectionState != ConnectionState.Disconnected)

  139.                 await DisconnectInternalAsync(null, false).ConfigureAwait(false);

  140. 

  141.             _applicationInfo = null;

  142.             _voiceRegions = ImmutableDictionary.Create<string, RestVoiceRegion>();

  143.         }

  144.         

  145.         /// <inheritdoc />

  146.         public async Task ConnectAsync(bool waitForGuilds = true)

  147.         {

  148.             await _connectionLock.WaitAsync().ConfigureAwait(false);

  149.             try

  150.             {

  151.                 await ConnectInternalAsync(false).ConfigureAwait(false);

  152.             }

  153.             finally { _connectionLock.Release(); }

  154. 

  155.             if (waitForGuilds)

  156.             {

  157.                 var downloadTask = _guildDownloadTask;

  158.                 if (downloadTask != null)

  159.                     await _guildDownloadTask.ConfigureAwait(false);

  160.             }

  161.         }

  162.         private async Task ConnectInternalAsync(bool isReconnecting)

  163.         {

  164.             if (LoginState != LoginState.LoggedIn)

  165.                 throw new InvalidOperationException("Client is not logged in.");

  166. 

  167.             if (!isReconnecting && _reconnectCancelToken != null && !_reconnectCancelToken.IsCancellationRequested)

  168.                 _reconnectCancelToken.Cancel();

  169. 

  170.             var state = ConnectionState;

  171.             if (state == ConnectionState.Connecting || state == ConnectionState.Connected)

  172.                 await DisconnectInternalAsync(null, isReconnecting).ConfigureAwait(false);

  173. 

  174.             ConnectionState = ConnectionState.Connecting;

  175.             await _gatewayLogger.InfoAsync("Connecting").ConfigureAwait(false);

  176.             

  177.             try

  178.             {

  179.                 var connectTask = new TaskCompletionSource<bool>();

  180.                 _connectTask = connectTask;

  181.                 _cancelToken = new CancellationTokenSource();

  182. 

  183.                 //Abort connection on timeout

  184.                 var _ = Task.Run(async () =>

  185.                 {

  186.                     await Task.Delay(ConnectionTimeout).ConfigureAwait(false);

  187.                     connectTask.TrySetException(new TimeoutException());

  188.                 });

  189. 

  190.                 await _gatewayLogger.DebugAsync("Connecting ApiClient").ConfigureAwait(false);

  191.                 await ApiClient.ConnectAsync().ConfigureAwait(false);

  192.                 await _gatewayLogger.DebugAsync("Raising Event").ConfigureAwait(false);

  193.                 await _connectedEvent.InvokeAsync().ConfigureAwait(false);

  194. 

  195.                 if (_sessionId != null)

  196.                 {

  197.                     await _gatewayLogger.DebugAsync("Resuming").ConfigureAwait(false);

  198.                     await ApiClient.SendResumeAsync(_sessionId, _lastSeq).ConfigureAwait(false);

  199.                 }

  200.                 else

  201.                 {

  202.                     await _gatewayLogger.DebugAsync("Identifying").ConfigureAwait(false);

  203.                     await ApiClient.SendIdentifyAsync(shardID: ShardId, totalShards: TotalShards).ConfigureAwait(false);

  204.                 }

  205. 

  206.                 await _connectTask.Task.ConfigureAwait(false);

  207. 

  208.                 await _gatewayLogger.DebugAsync("Sending Status").ConfigureAwait(false);

  209.                 await SendStatus().ConfigureAwait(false);

  210. 

  211.                 await _gatewayLogger.DebugAsync("Raising Event").ConfigureAwait(false);

  212.                 if (!isReconnecting)

  213.                     _canReconnect = true;

  214.                 ConnectionState = ConnectionState.Connected;

  215.                 await _gatewayLogger.InfoAsync("Connected").ConfigureAwait(false);

  216.             }

  217.             catch (Exception)

  218.             {

  219.                 await DisconnectInternalAsync(null, isReconnecting).ConfigureAwait(false);

  220.                 throw;

  221.             }

  222.         }

  223.         /// <inheritdoc />

  224.         public async Task DisconnectAsync()

  225.         {

  226.             if (_connectTask?.TrySetCanceled() ?? false) return;

  227.             await _connectionLock.WaitAsync().ConfigureAwait(false);

  228.             try

  229.             {

  230.                 await DisconnectInternalAsync(null, false).ConfigureAwait(false);

  231.             }

  232.             finally { _connectionLock.Release(); }

  233.         }

  234.         private async Task DisconnectInternalAsync(Exception ex, bool isReconnecting)

  235.         {

  236.             if (!isReconnecting)

  237.             {

  238.                 _canReconnect = false;

  239.                 _sessionId = null;

  240.                 _lastSeq = 0;

  241. 

  242.                 if (_reconnectCancelToken != null && !_reconnectCancelToken.IsCancellationRequested)

  243.                     _reconnectCancelToken.Cancel();

  244.             }

  245. 

  246.             ulong guildId;

  247. 

  248.             if (ConnectionState == ConnectionState.Disconnected) return;

  249.             ConnectionState = ConnectionState.Disconnecting;

  250.             await _gatewayLogger.InfoAsync("Disconnecting").ConfigureAwait(false);

  251. 

  252.             await _gatewayLogger.DebugAsync("Cancelling current tasks").ConfigureAwait(false);

  253.             //Signal tasks to complete

  254.             try { _cancelToken.Cancel(); } catch { }

  255. 

  256.             await _gatewayLogger.DebugAsync("Disconnecting ApiClient").ConfigureAwait(false);

  257.             //Disconnect from server

  258.             await ApiClient.DisconnectAsync().ConfigureAwait(false);

  259. 

  260.             //Wait for tasks to complete

  261.             await _gatewayLogger.DebugAsync("Waiting for heartbeater").ConfigureAwait(false);

  262.             var heartbeatTask = _heartbeatTask;

  263.             if (heartbeatTask != null)

  264.                 await heartbeatTask.ConfigureAwait(false);

  265.             _heartbeatTask = null;

  266. 

  267.             await _gatewayLogger.DebugAsync("Waiting for guild downloader").ConfigureAwait(false);

  268.             var guildDownloadTask = _guildDownloadTask;

  269.             if (guildDownloadTask != null)

  270.                 await guildDownloadTask.ConfigureAwait(false);

  271.             _guildDownloadTask = null;

  272. 

  273.             //Clear large guild queue

  274.             await _gatewayLogger.DebugAsync("Clearing large guild queue").ConfigureAwait(false);

  275.             while (_largeGuilds.TryDequeue(out guildId)) { }

  276. 

  277.             //Raise virtual GUILD_UNAVAILABLEs

  278.             await _gatewayLogger.DebugAsync("Raising virtual GuildUnavailables").ConfigureAwait(false);

  279.             foreach (var guild in State.Guilds)

  280.             {

  281.                 if (guild._available)

  282.                     await _guildUnavailableEvent.InvokeAsync(guild).ConfigureAwait(false);

  283.             }

  284. 

  285.             ConnectionState = ConnectionState.Disconnected;

  286.             await _gatewayLogger.InfoAsync("Disconnected").ConfigureAwait(false);

  287. 

  288.             await _disconnectedEvent.InvokeAsync(ex).ConfigureAwait(false);

  289.         }

  290. 

  291.         private async Task StartReconnectAsync(Exception ex)

  292.         {

  293.             if (ex == null)

  294.             {

  295.                 if (_connectTask?.TrySetCanceled() ?? false) return;

  296.             }

  297.             else

  298.             {

  299.                 if (_connectTask?.TrySetException(ex) ?? false) return;

  300.             }

  301. 

  302.             await _connectionLock.WaitAsync().ConfigureAwait(false);

  303.             try

  304.             {

  305.                 if (!_canReconnect || _reconnectTask != null) return;

  306.                 _reconnectCancelToken = new CancellationTokenSource();

  307.                 _reconnectTask = ReconnectInternalAsync(ex, _reconnectCancelToken.Token);

  308.             }

  309.             finally { _connectionLock.Release(); }

  310.         }

  311.         private async Task ReconnectInternalAsync(Exception ex, CancellationToken cancelToken)

  312.         {

  313.             try

  314.             {

  315.                 Random jitter = new Random();

  316.                 int nextReconnectDelay = 1000;

  317.                 while (true)

  318.                 {

  319.                     await Task.Delay(nextReconnectDelay, cancelToken).ConfigureAwait(false);

  320.                     nextReconnectDelay = nextReconnectDelay * 2 + jitter.Next(-250, 250);

  321.                     if (nextReconnectDelay > 60000)

  322.                         nextReconnectDelay = 60000;

  323. 

  324.                     await _connectionLock.WaitAsync().ConfigureAwait(false);

  325.                     try

  326.                     {

  327.                         if (cancelToken.IsCancellationRequested) return;

  328.                         await ConnectInternalAsync(true).ConfigureAwait(false);

  329.                         _reconnectTask = null;

  330.                         return;

  331.                     }

  332.                     catch (Exception ex2)

  333.                     {

  334.                         await _gatewayLogger.WarningAsync("Reconnect failed", ex2).ConfigureAwait(false);

  335.                     }

  336.                     finally {  _connectionLock.Release(); }

  337.                 }

  338.             }

  339.             catch (OperationCanceledException)

  340.             {

  341.                 await _connectionLock.WaitAsync().ConfigureAwait(false);

  342.                 try

  343.                 {

  344.                     await _gatewayLogger.DebugAsync("Reconnect cancelled").ConfigureAwait(false);

  345.                     _reconnectTask = null;

  346.                 }

  347.                 finally { _connectionLock.Release(); }

  348.             }

  349.         }

  350. 

  351.         /// <inheritdoc />

  352.         public async Task<RestApplication> GetApplicationInfoAsync()

  353.         { 

  354.             return _applicationInfo ?? (_applicationInfo = await ClientHelper.GetApplicationInfoAsync(this));

  355.         }

  356. 

  357.         /// <inheritdoc />

  358.         public SocketGuild GetGuild(ulong id)

  359.         {

  360.             return State.GetGuild(id);

  361.         }

  362.         /// <inheritdoc />

  363.         public Task<RestGuild> CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon = null)

  364.             => ClientHelper.CreateGuildAsync(this, name, region, jpegIcon);

  365. 

  366.         /// <inheritdoc />

  367.         public SocketChannel GetChannel(ulong id)

  368.         {

  369.             return State.GetChannel(id);

  370.         }

  371. 

  372.         /// <inheritdoc />

  373.         public Task<IReadOnlyCollection<RestConnection>> GetConnectionsAsync()

  374.             => ClientHelper.GetConnectionsAsync(this);

  375. 

  376.         /// <inheritdoc />

  377.         public Task<RestInvite> GetInviteAsync(string inviteId)

  378.             => ClientHelper.GetInviteAsync(this, inviteId);

  379. 

  380.         /// <inheritdoc />

  381.         public SocketUser GetUser(ulong id)

  382.         {

  383.             return State.GetUser(id);

  384.         }

  385.         /// <inheritdoc />

  386.         public SocketUser GetUser(string username, string discriminator)

  387.         {

  388.             return State.Users.Where(x => x.Discriminator == discriminator && x.Username == username).FirstOrDefault();

  389.         }

  390.         internal SocketGlobalUser GetOrCreateUser(ClientState state, Discord.API.User model)

  391.         {

  392.             return state.GetOrAddUser(model.Id, x =>

  393.             {

  394.                 var user = SocketGlobalUser.Create(this, state, model);

  395.                 user.GlobalUser.AddRef();

  396.                 return user;

  397.             });

  398.         }

  399.         internal SocketGlobalUser GetOrCreateSelfUser(ClientState state, Discord.API.User model)

  400.         {

  401.             return state.GetOrAddUser(model.Id, x =>

  402.             {

  403.                 var user = SocketGlobalUser.Create(this, state, model);

  404.                 user.GlobalUser.AddRef();

  405.                 user.Presence = new SocketPresence(UserStatus.Online, null);

  406.                 return user;

  407.             });

  408.         }

  409.         internal void RemoveUser(ulong id)

  410.         {

  411.             State.RemoveUser(id);

  412.         }

  413. 

  414.         /// <inheritdoc />

  415.         public RestVoiceRegion GetVoiceRegion(string id)

  416.         {

  417.             RestVoiceRegion region;

  418.             if (_voiceRegions.TryGetValue(id, out region))

  419.                 return region;

  420.             return null;

  421.         }

  422. 

  423.         /// <summary> Downloads the users list for all large guilds. </summary>

  424.         public Task DownloadAllUsersAsync() 

  425.             => DownloadUsersAsync(State.Guilds.Where(x => !x.HasAllMembers));

  426.         /// <summary> Downloads the users list for the provided guilds, if they don't have a complete list. </summary>

  427.         public Task DownloadUsersAsync(IEnumerable<IGuild> guilds)

  428.             => DownloadUsersAsync(guilds.Select(x => x as SocketGuild).Where(x => x != null));

  429.         public Task DownloadUsersAsync(params IGuild[] guilds)

  430.             => DownloadUsersAsync(guilds.Select(x => x as SocketGuild).Where(x => x != null));

  431.         private async Task DownloadUsersAsync(IEnumerable<SocketGuild> guilds)

  432.         {

  433.             var cachedGuilds = guilds.ToImmutableArray();

  434.             if (cachedGuilds.Length == 0) return;

  435. 

  436.             //Wait for unsynced guilds to sync first.

  437.             var unsyncedGuilds = guilds.Select(x => x.SyncPromise).Where(x => !x.IsCompleted).ToImmutableArray();

  438.             if (unsyncedGuilds.Length > 0)

  439.                 await Task.WhenAll(unsyncedGuilds).ConfigureAwait(false);

  440. 

  441.             //Download offline members

  442.             const short batchSize = 50;

  443. 

  444.             if (cachedGuilds.Length == 1)

  445.             {

  446.                 if (!cachedGuilds[0].HasAllMembers)

  447.                     await ApiClient.SendRequestMembersAsync(new ulong[] { cachedGuilds[0].Id }).ConfigureAwait(false);

  448.                 await cachedGuilds[0].DownloaderPromise.ConfigureAwait(false);

  449.                 return;

  450.             }

  451. 

  452.             ulong[] batchIds = new ulong[Math.Min(batchSize, cachedGuilds.Length)];

  453.             Task[] batchTasks = new Task[batchIds.Length];

  454.             int batchCount = (cachedGuilds.Length + (batchSize - 1)) / batchSize;

  455. 

  456.             for (int i = 0, k = 0; i < batchCount; i++)

  457.             {

  458.                 bool isLast = i == batchCount - 1;

  459.                 int count = isLast ? (batchIds.Length - (batchCount - 1) * batchSize) : batchSize;

  460. 

  461.                 for (int j = 0; j < count; j++, k++)

  462.                 {

  463.                     var guild = cachedGuilds[k];

  464.                     batchIds[j] = guild.Id;

  465.                     batchTasks[j] = guild.DownloaderPromise;

  466.                 }

  467. 

  468.                 await ApiClient.SendRequestMembersAsync(batchIds).ConfigureAwait(false);

  469. 

  470.                 if (isLast && batchCount > 1)

  471.                     await Task.WhenAll(batchTasks.Take(count)).ConfigureAwait(false);

  472.                 else

  473.                     await Task.WhenAll(batchTasks).ConfigureAwait(false);

  474.             }

  475.         }

  476. 

  477.         public async Task SetStatus(UserStatus status)

  478.         {

  479.             Status = status;

  480.             if (status == UserStatus.AFK)

  481.                 _statusSince = DateTimeOffset.UtcNow;

  482.             else

  483.                 _statusSince = null;

  484.             await SendStatus().ConfigureAwait(false);

  485.         }

  486.         public async Task SetGame(string name, string streamUrl = null, StreamType streamType = StreamType.NotStreaming)

  487.         {

  488.             if (name != null)

  489.                 Game = new Game(name, streamUrl, streamType);

  490.             else

  491.                 Game = null;

  492.             CurrentUser.Presence = new SocketPresence(Status, Game);

  493.             await SendStatus().ConfigureAwait(false);

  494.         }

  495.         private async Task SendStatus()

  496.         {

  497.             var game = Game;

  498.             var status = Status;

  499.             var statusSince = _statusSince;

  500.             CurrentUser.Presence = new SocketPresence(status, game);

  501. 

  502.             GameModel gameModel;

  503.             if (game != null)

  504.             {

  505.                 gameModel = new API.Game

  506.                 {

  507.                     Name = game.Value.Name,

  508.                     StreamType = game.Value.StreamType,

  509.                     StreamUrl = game.Value.StreamUrl

  510.                 };

  511.             }

  512.             else

  513.                 gameModel = null;

  514. 

  515.             await ApiClient.SendStatusUpdateAsync(

  516.                 status,

  517.                 status == UserStatus.AFK,

  518.                 statusSince != null ? DateTimeUtils.ToUnixMilliseconds(_statusSince.Value) : (long?)null,

  519.                 gameModel).ConfigureAwait(false);

  520.         }

  521. 

  522.         private async Task ProcessMessageAsync(GatewayOpCode opCode, int? seq, string type, object payload)

  523.         {

  524.             if (seq != null)

  525.                 _lastSeq = seq.Value;

  526.             try

  527.             {

  528.                 switch (opCode)

  529.                 {

  530.                     case GatewayOpCode.Hello:

  531.                         {

  532.                             await _gatewayLogger.DebugAsync("Received Hello").ConfigureAwait(false);

  533.                             var data = (payload as JToken).ToObject<HelloEvent>(_serializer);

  534. 

  535.                             _heartbeatTime = 0;

  536.                             _heartbeatTask = RunHeartbeatAsync(data.HeartbeatInterval, _cancelToken.Token, LogManager.ClientLogger);

  537.                         }

  538.                         break;

  539.                     case GatewayOpCode.Heartbeat:

  540.                         {

  541.                             await _gatewayLogger.DebugAsync("Received Heartbeat").ConfigureAwait(false);

  542.                             

  543.                             await ApiClient.SendHeartbeatAsync(_lastSeq).ConfigureAwait(false);

  544.                         }

  545.                         break;

  546.                     case GatewayOpCode.HeartbeatAck:

  547.                         {

  548.                             await _gatewayLogger.DebugAsync("Received HeartbeatAck").ConfigureAwait(false);

  549. 

  550.                             var heartbeatTime = _heartbeatTime;

  551.                             if (heartbeatTime != 0)

  552.                             {

  553.                                 int latency = (int)(Environment.TickCount - _heartbeatTime);

  554.                                 _heartbeatTime = 0;

  555. 

  556.                                 int before = Latency;

  557.                                 Latency = latency;

  558. 

  559.                                 await _latencyUpdatedEvent.InvokeAsync(before, latency).ConfigureAwait(false);

  560.                             }

  561.                         }

  562.                         break;

  563.                     case GatewayOpCode.InvalidSession:

  564.                         {

  565.                             await _gatewayLogger.DebugAsync("Received InvalidSession").ConfigureAwait(false);

  566.                             await _gatewayLogger.WarningAsync("Failed to resume previous session").ConfigureAwait(false);

  567. 

  568.                             _sessionId = null;

  569.                             _lastSeq = 0;

  570.                             await ApiClient.SendIdentifyAsync(shardID: ShardId, totalShards: TotalShards).ConfigureAwait(false);

  571.                         }

  572.                         break;

  573.                     case GatewayOpCode.Reconnect:

  574.                         {

  575.                             await _gatewayLogger.DebugAsync("Received Reconnect").ConfigureAwait(false);

  576.                             await _gatewayLogger.WarningAsync("Server requested a reconnect").ConfigureAwait(false);

  577. 

  578.                             await StartReconnectAsync(new Exception("Server requested a reconnect")).ConfigureAwait(false);

  579.                         }

  580.                         break;

  581.                     case GatewayOpCode.Dispatch:

  582.                         switch (type)

  583.                         {

  584.                             //Connection

  585.                             case "READY":

  586.                                 {

  587.                                     try

  588.                                     {

  589.                                         await _gatewayLogger.DebugAsync("Received Dispatch (READY)").ConfigureAwait(false);

  590. 

  591.                                         var data = (payload as JToken).ToObject<ReadyEvent>(_serializer);

  592.                                         var state = new ClientState(data.Guilds.Length, data.PrivateChannels.Length);

  593. 

  594.                                         var currentUser = SocketSelfUser.Create(this, state, data.User);

  595.                                         int unavailableGuilds = 0;

  596.                                         for (int i = 0; i < data.Guilds.Length; i++)

  597.                                         {

  598.                                             var model = data.Guilds[i];

  599.                                             var guild = AddGuild(model, state);

  600.                                             if (!guild._available || ApiClient.AuthTokenType == TokenType.User)

  601.                                                 unavailableGuilds++;

  602.                                             else

  603.                                                 await _guildAvailableEvent.InvokeAsync(guild).ConfigureAwait(false);

  604.                                         }

  605.                                         for (int i = 0; i < data.PrivateChannels.Length; i++)

  606.                                             AddPrivateChannel(data.PrivateChannels[i], state);

  607. 

  608.                                         _sessionId = data.SessionId;

  609.                                         _unavailableGuilds = unavailableGuilds;

  610.                                         CurrentUser = currentUser;

  611.                                         State = state;

  612.                                     }

  613.                                     catch (Exception ex)

  614.                                     {

  615.                                         _connectTask.TrySetException(new Exception("Processing READY failed", ex));

  616.                                         return;

  617.                                     }

  618. 

  619.                                     if (ApiClient.AuthTokenType == TokenType.User)

  620.                                         await SyncGuildsAsync().ConfigureAwait(false);

  621. 

  622.                                     _lastGuildAvailableTime = Environment.TickCount;

  623.                                     _guildDownloadTask = WaitForGuildsAsync(_cancelToken.Token, LogManager.ClientLogger);

  624. 

  625.                                     await _readyEvent.InvokeAsync().ConfigureAwait(false);

  626. 

  627.                                     var _ = _connectTask.TrySetResultAsync(true); //Signal the .Connect() call to complete

  628.                                     await _gatewayLogger.InfoAsync("Ready").ConfigureAwait(false);

  629.                                 }

  630.                                 break;

  631.                             case "RESUMED":

  632.                                 {

  633.                                     await _gatewayLogger.DebugAsync("Received Dispatch (RESUMED)").ConfigureAwait(false);

  634. 

  635.                                     var _ = _connectTask.TrySetResultAsync(true); //Signal the .Connect() call to complete

  636. 

  637.                                     //Notify the client that these guilds are available again

  638.                                     foreach (var guild in State.Guilds)

  639.                                     {

  640.                                         if (guild._available)

  641.                                             await _guildAvailableEvent.InvokeAsync(guild).ConfigureAwait(false);

  642.                                     }

  643. 

  644.                                     await _gatewayLogger.InfoAsync("Resumed previous session").ConfigureAwait(false);

  645.                                 }

  646.                                 return;

  647. 

  648.                             //Guilds

  649.                             case "GUILD_CREATE":

  650.                                 {

  651.                                     var data = (payload as JToken).ToObject<ExtendedGuild>(_serializer);

  652. 

  653.                                     if (data.Unavailable == false)

  654.                                     {

  655.                                         type = "GUILD_AVAILABLE";

  656.                                         _lastGuildAvailableTime = Environment.TickCount;

  657.                                         await _gatewayLogger.DebugAsync($"Received Dispatch (GUILD_AVAILABLE)").ConfigureAwait(false);

  658. 

  659.                                         var guild = State.GetGuild(data.Id);

  660.                                         if (guild != null)

  661.                                         {

  662.                                             guild.Update(State, data);

  663. 

  664.                                             var unavailableGuilds = _unavailableGuilds;

  665.                                             if (unavailableGuilds != 0)

  666.                                                 _unavailableGuilds = unavailableGuilds - 1;

  667.                                             await _guildAvailableEvent.InvokeAsync(guild).ConfigureAwait(false);

  668.                                         }

  669.                                         else

  670.                                         {

  671.                                             await _gatewayLogger.WarningAsync($"GUILD_AVAILABLE referenced an unknown guild.").ConfigureAwait(false);

  672.                                             return;

  673.                                         }

  674.                                     }

  675.                                     else

  676.                                     {

  677.                                         await _gatewayLogger.DebugAsync($"Received Dispatch (GUILD_CREATE)").ConfigureAwait(false);

  678. 

  679.                                         var guild = AddGuild(data, State);

  680.                                         if (guild != null)

  681.                                         {

  682.                                             if (ApiClient.AuthTokenType == TokenType.User)

  683.                                                 await SyncGuildsAsync().ConfigureAwait(false);

  684.                                             await _joinedGuildEvent.InvokeAsync(guild).ConfigureAwait(false);

  685.                                         }

  686.                                         else

  687.                                         {

  688.                                             await _gatewayLogger.WarningAsync($"GUILD_CREATE referenced an unknown guild.").ConfigureAwait(false);

  689.                                             return;

  690.                                         }

  691.                                     }

  692.                                 }

  693.                                 break;

  694.                             case "GUILD_UPDATE":

  695.                                 {

  696.                                     await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_UPDATE)").ConfigureAwait(false);

  697. 

  698.                                     var data = (payload as JToken).ToObject<API.Guild>(_serializer);

  699.                                     var guild = State.GetGuild(data.Id);

  700.                                     if (guild != null)

  701.                                     {

  702.                                         var before = guild.Clone();

  703.                                         guild.Update(State, data);

  704.                                         await _guildUpdatedEvent.InvokeAsync(before, guild).ConfigureAwait(false);

  705.                                     }

  706.                                     else

  707.                                     {

  708.                                         await _gatewayLogger.WarningAsync("GUILD_UPDATE referenced an unknown guild.").ConfigureAwait(false);

  709.                                         return;

  710.                                     }

  711.                                 }

  712.                                 break;

  713.                             case "GUILD_EMOJIS_UPDATE":

  714.                                 {

  715.                                     await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_EMOJIS_UPDATE)").ConfigureAwait(false);

  716. 

  717.                                     var data = (payload as JToken).ToObject<API.Gateway.GuildEmojiUpdateEvent>(_serializer);

  718.                                     var guild = State.GetGuild(data.GuildId);

  719.                                     if (guild != null)

  720.                                     {

  721.                                         var before = guild.Clone();

  722.                                         guild.Update(State, data);

  723.                                         await _guildUpdatedEvent.InvokeAsync(before, guild).ConfigureAwait(false);

  724.                                     }

  725.                                     else

  726.                                     {

  727.                                         await _gatewayLogger.WarningAsync("GUILD_EMOJIS_UPDATE referenced an unknown guild.").ConfigureAwait(false);

  728.                                         return;

  729.                                     }

  730.                                 }

  731.                                 return;

  732.                             case "GUILD_SYNC":

  733.                                 {

  734.                                     await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_SYNC)").ConfigureAwait(false);

  735.                                     var data = (payload as JToken).ToObject<GuildSyncEvent>(_serializer);

  736.                                     var guild = State.GetGuild(data.Id);

  737.                                     if (guild != null)

  738.                                     {

  739.                                         var before = guild.Clone();

  740.                                         guild.Update(State, data);

  741.                                         //This is treated as an extension of GUILD_AVAILABLE

  742.                                         _unavailableGuilds--;

  743.                                         _lastGuildAvailableTime = Environment.TickCount;

  744.                                         await _guildAvailableEvent.InvokeAsync(guild).ConfigureAwait(false);

  745.                                         await _guildUpdatedEvent.InvokeAsync(before, guild).ConfigureAwait(false);

  746.                                     }

  747.                                     else

  748.                                     {

  749.                                         await _gatewayLogger.WarningAsync("GUILD_SYNC referenced an unknown guild.").ConfigureAwait(false);

  750.                                         return;

  751.                                     }

  752.                                 }

  753.                                 return;

  754.                             case "GUILD_DELETE":

  755.                                 {

  756.                                     var data = (payload as JToken).ToObject<ExtendedGuild>(_serializer);

  757.                                     if (data.Unavailable == true)

  758.                                     {

  759.                                         type = "GUILD_UNAVAILABLE";

  760.                                         await _gatewayLogger.DebugAsync($"Received Dispatch (GUILD_UNAVAILABLE)").ConfigureAwait(false);

  761. 

  762.                                         var guild = State.GetGuild(data.Id);

  763.                                         if (guild != null)

  764.                                         {

  765.                                             await _guildUnavailableEvent.InvokeAsync(guild).ConfigureAwait(false);

  766.                                             _unavailableGuilds++;

  767.                                         }

  768.                                         else

  769.                                         {

  770.                                             await _gatewayLogger.WarningAsync($"GUILD_UNAVAILABLE referenced an unknown guild.").ConfigureAwait(false);

  771.                                             return;

  772.                                         }

  773.                                     }

  774.                                     else

  775.                                     {

  776.                                         await _gatewayLogger.DebugAsync($"Received Dispatch (GUILD_DELETE)").ConfigureAwait(false);

  777. 

  778.                                         var guild = RemoveGuild(data.Id);

  779.                                         if (guild != null)

  780.                                         {

  781.                                             await _guildUnavailableEvent.InvokeAsync(guild).ConfigureAwait(false);

  782.                                             await _leftGuildEvent.InvokeAsync(guild).ConfigureAwait(false);

  783.                                         }

  784.                                         else

  785.                                         {

  786.                                             await _gatewayLogger.WarningAsync($"GUILD_DELETE referenced an unknown guild.").ConfigureAwait(false);

  787.                                             return;

  788.                                         }

  789.                                     }

  790.                                 }

  791.                                 break;

  792. 

  793.                             //Channels

  794.                             case "CHANNEL_CREATE":

  795.                                 {

  796.                                     await _gatewayLogger.DebugAsync("Received Dispatch (CHANNEL_CREATE)").ConfigureAwait(false);

  797. 

  798.                                     var data = (payload as JToken).ToObject<API.Channel>(_serializer);

  799.                                     SocketChannel channel = null;

  800.                                     if (data.GuildId.IsSpecified)

  801.                                     {

  802.                                         var guild = State.GetGuild(data.GuildId.Value);

  803.                                         if (guild != null)

  804.                                         {

  805.                                             channel = guild.AddChannel(State, data);

  806. 

  807.                                             if (!guild.IsSynced)

  808.                                             {

  809.                                                 await _gatewayLogger.DebugAsync("Ignored CHANNEL_CREATE, guild is not synced yet.").ConfigureAwait(false);

  810.                                                 return;

  811.                                             }

  812.                                         }

  813.                                         else

  814.                                         {

  815.                                             await _gatewayLogger.WarningAsync("CHANNEL_CREATE referenced an unknown guild.").ConfigureAwait(false);

  816.                                             return;

  817.                                         }

  818.                                     }

  819.                                     else

  820.                                         channel = AddPrivateChannel(data, State) as SocketChannel;

  821. 

  822.                                     if (channel != null)

  823.                                         await _channelCreatedEvent.InvokeAsync(channel).ConfigureAwait(false);

  824.                                 }

  825.                                 break;

  826.                             case "CHANNEL_UPDATE":

  827.                                 {

  828.                                     await _gatewayLogger.DebugAsync("Received Dispatch (CHANNEL_UPDATE)").ConfigureAwait(false);

  829. 

  830.                                     var data = (payload as JToken).ToObject<API.Channel>(_serializer);

  831.                                     var channel = State.GetChannel(data.Id);

  832.                                     if (channel != null)

  833.                                     {

  834.                                         var before = channel.Clone();

  835.                                         channel.Update(State, data);

  836. 

  837.                                         if (!((channel as SocketGuildChannel)?.Guild.IsSynced ?? true))

  838.                                         {

  839.                                             await _gatewayLogger.DebugAsync("Ignored CHANNEL_UPDATE, guild is not synced yet.").ConfigureAwait(false);

  840.                                             return;

  841.                                         }

  842. 

  843.                                         await _channelUpdatedEvent.InvokeAsync(before, channel).ConfigureAwait(false);

  844.                                     }

  845.                                     else

  846.                                     {

  847.                                         await _gatewayLogger.WarningAsync("CHANNEL_UPDATE referenced an unknown channel.").ConfigureAwait(false);

  848.                                         return;

  849.                                     }

  850.                                 }

  851.                                 break;

  852.                             case "CHANNEL_DELETE":

  853.                                 {

  854.                                     await _gatewayLogger.DebugAsync("Received Dispatch (CHANNEL_DELETE)").ConfigureAwait(false);

  855. 

  856.                                     SocketChannel channel = null;

  857.                                     var data = (payload as JToken).ToObject<API.Channel>(_serializer);

  858.                                     if (data.GuildId.IsSpecified)

  859.                                     {

  860.                                         var guild = State.GetGuild(data.GuildId.Value);

  861.                                         if (guild != null)

  862.                                         {

  863.                                             channel = guild.RemoveChannel(State, data.Id);

  864. 

  865.                                             if (!guild.IsSynced)

  866.                                             {

  867.                                                 await _gatewayLogger.DebugAsync("Ignored CHANNEL_DELETE, guild is not synced yet.").ConfigureAwait(false);

  868.                                                 return;

  869.                                             }

  870.                                         }

  871.                                         else

  872.                                         {

  873.                                             await _gatewayLogger.WarningAsync("CHANNEL_DELETE referenced an unknown guild.").ConfigureAwait(false);

  874.                                             return;

  875.                                         }

  876.                                     }

  877.                                     else

  878.                                         channel = RemovePrivateChannel(data.Id) as SocketChannel;

  879. 

  880.                                     if (channel != null)

  881.                                         await _channelDestroyedEvent.InvokeAsync(channel).ConfigureAwait(false);

  882.                                     else

  883.                                     {

  884.                                         await _gatewayLogger.WarningAsync("CHANNEL_DELETE referenced an unknown channel.").ConfigureAwait(false);

  885.                                         return;

  886.                                     }

  887.                                 }

  888.                                 break;

  889. 

  890.                             //Members

  891.                             case "GUILD_MEMBER_ADD":

  892.                                 {

  893.                                     await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_MEMBER_ADD)").ConfigureAwait(false);

  894. 

  895.                                     var data = (payload as JToken).ToObject<GuildMemberAddEvent>(_serializer);

  896.                                     var guild = State.GetGuild(data.GuildId);

  897.                                     if (guild != null)

  898.                                     {

  899.                                         var user = guild.AddOrUpdateUser(data);

  900.                                         guild.MemberCount++;

  901. 

  902.                                         if (!guild.IsSynced)

  903.                                         {

  904.                                             await _gatewayLogger.DebugAsync("Ignored GUILD_MEMBER_ADD, guild is not synced yet.").ConfigureAwait(false);

  905.                                             return;

  906.                                         }

  907. 

  908.                                         await _userJoinedEvent.InvokeAsync(user).ConfigureAwait(false);

  909.                                     }

  910.                                     else

  911.                                     {

  912.                                         await _gatewayLogger.WarningAsync("GUILD_MEMBER_ADD referenced an unknown guild.").ConfigureAwait(false);

  913.                                         return;

  914.                                     }

  915.                                 }

  916.                                 break;

  917.                             case "GUILD_MEMBER_UPDATE":

  918.                                 {

  919.                                     await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_MEMBER_UPDATE)").ConfigureAwait(false);

  920. 

  921.                                     var data = (payload as JToken).ToObject<GuildMemberUpdateEvent>(_serializer);

  922.                                     var guild = State.GetGuild(data.GuildId);

  923.                                     if (guild != null)

  924.                                     {

  925.                                         var user = guild.GetUser(data.User.Id);

  926. 

  927.                                         if (!guild.IsSynced)

  928.                                         {

  929.                                             await _gatewayLogger.DebugAsync("Ignored GUILD_MEMBER_UPDATE, guild is not synced yet.").ConfigureAwait(false);

  930.                                             return;

  931.                                         }

  932. 

  933.                                         if (user != null)

  934.                                         {

  935.                                             var before = user.Clone();

  936.                                             user.Update(State, data);

  937.                                             await _guildMemberUpdatedEvent.InvokeAsync(before, user).ConfigureAwait(false);

  938.                                         }

  939.                                         else

  940.                                         {

  941.                                             if (!guild.HasAllMembers)

  942.                                             {

  943.                                                 await _gatewayLogger.DebugAsync("Ignored GUILD_MEMBER_UPDATE, this user has not been downloaded yet.").ConfigureAwait(false);

  944.                                                 return;

  945.                                             }

  946. 

  947.                                             await _gatewayLogger.WarningAsync("GUILD_MEMBER_UPDATE referenced an unknown user.").ConfigureAwait(false);

  948.                                             return;

  949.                                         }

  950.                                     }

  951.                                     else

  952.                                     {

  953.                                         await _gatewayLogger.WarningAsync("GUILD_MEMBER_UPDATE referenced an unknown guild.").ConfigureAwait(false);

  954.                                         return;

  955.                                     }

  956.                                 }

  957.                                 break;

  958.                             case "GUILD_MEMBER_REMOVE":

  959.                                 {

  960.                                     await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_MEMBER_REMOVE)").ConfigureAwait(false);

  961. 

  962.                                     var data = (payload as JToken).ToObject<GuildMemberRemoveEvent>(_serializer);

  963.                                     var guild = State.GetGuild(data.GuildId);

  964.                                     if (guild != null)

  965.                                     {

  966.                                         var user = guild.RemoveUser(data.User.Id);

  967.                                         guild.MemberCount--;

  968. 

  969.                                         if (!guild.IsSynced)

  970.                                         {

  971.                                             await _gatewayLogger.DebugAsync("Ignored GUILD_MEMBER_REMOVE, guild is not synced yet.").ConfigureAwait(false);

  972.                                             return;

  973.                                         }

  974. 

  975.                                         if (user != null)

  976.                                             await _userLeftEvent.InvokeAsync(user).ConfigureAwait(false);

  977.                                         else

  978.                                         {

  979.                                             if (!guild.HasAllMembers)

  980.                                             {

  981.                                                 await _gatewayLogger.DebugAsync("Ignored GUILD_MEMBER_REMOVE, this user has not been downloaded yet.").ConfigureAwait(false);

  982.                                                 return;

  983.                                             }

  984. 

  985.                                             await _gatewayLogger.WarningAsync("GUILD_MEMBER_REMOVE referenced an unknown user.").ConfigureAwait(false);

  986.                                             return;

  987.                                         }

  988.                                     }

  989.                                     else

  990.                                     {

  991.                                         await _gatewayLogger.WarningAsync("GUILD_MEMBER_REMOVE referenced an unknown guild.").ConfigureAwait(false);

  992.                                         return;

  993.                                     }

  994.                                 }

  995.                                 break;

  996.                             case "GUILD_MEMBERS_CHUNK":

  997.                                 {

  998.                                     await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_MEMBERS_CHUNK)").ConfigureAwait(false);

  999. 

  1000.                                     var data = (payload as JToken).ToObject<GuildMembersChunkEvent>(_serializer);

  1001.                                     var guild = State.GetGuild(data.GuildId);

  1002.                                     if (guild != null)

  1003.                                     {

  1004.                                         foreach (var memberModel in data.Members)

  1005.                                             guild.AddOrUpdateUser(memberModel);

  1006. 

  1007.                                         if (guild.DownloadedMemberCount >= guild.MemberCount) //Finished downloading for there

  1008.                                         {

  1009.                                             guild.CompleteDownloadUsers();

  1010.                                             await _guildMembersDownloadedEvent.InvokeAsync(guild).ConfigureAwait(false);

  1011.                                         }

  1012.                                     }

  1013.                                     else

  1014.                                     {

  1015.                                         await _gatewayLogger.WarningAsync("GUILD_MEMBERS_CHUNK referenced an unknown guild.").ConfigureAwait(false);

  1016.                                         return;

  1017.                                     }

  1018.                                 }

  1019.                                 break;

  1020.                             case "CHANNEL_RECIPIENT_ADD":

  1021.                                 {

  1022.                                     await _gatewayLogger.DebugAsync("Received Dispatch (CHANNEL_RECIPIENT_ADD)").ConfigureAwait(false);

  1023. 

  1024.                                     var data = (payload as JToken).ToObject<RecipientEvent>(_serializer);

  1025.                                     var channel = State.GetChannel(data.ChannelId) as SocketGroupChannel;

  1026.                                     if (channel != null)

  1027.                                     {

  1028.                                         var user = channel.AddUser(data.User);

  1029.                                         await _recipientAddedEvent.InvokeAsync(user).ConfigureAwait(false);

  1030.                                     }

  1031.                                     else

  1032.                                     {

  1033.                                         await _gatewayLogger.WarningAsync("CHANNEL_RECIPIENT_ADD referenced an unknown channel.").ConfigureAwait(false);

  1034.                                         return;

  1035.                                     }

  1036.                                 }

  1037.                                 break;

  1038.                             case "CHANNEL_RECIPIENT_REMOVE":

  1039.                                 {

  1040.                                     await _gatewayLogger.DebugAsync("Received Dispatch (CHANNEL_RECIPIENT_REMOVE)").ConfigureAwait(false);

  1041. 

  1042.                                     var data = (payload as JToken).ToObject<RecipientEvent>(_serializer);

  1043.                                     var channel = State.GetChannel(data.ChannelId) as SocketGroupChannel;

  1044.                                     if (channel != null)

  1045.                                     {

  1046.                                         var user = channel.RemoveUser(data.User.Id);

  1047.                                         if (user != null)

  1048.                                             await _recipientRemovedEvent.InvokeAsync(user).ConfigureAwait(false);

  1049.                                         else

  1050.                                         {

  1051.                                             await _gatewayLogger.WarningAsync("CHANNEL_RECIPIENT_REMOVE referenced an unknown user.").ConfigureAwait(false);

  1052.                                             return;

  1053.                                         }

  1054.                                     }

  1055.                                     else

  1056.                                     {

  1057.                                         await _gatewayLogger.WarningAsync("CHANNEL_RECIPIENT_ADD referenced an unknown channel.").ConfigureAwait(false);

  1058.                                         return;

  1059.                                     }

  1060.                                 }

  1061.                                 break;

  1062. 

  1063.                             //Roles

  1064.                             case "GUILD_ROLE_CREATE":

  1065.                                 {

  1066.                                     await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_ROLE_CREATE)").ConfigureAwait(false);

  1067. 

  1068.                                     var data = (payload as JToken).ToObject<GuildRoleCreateEvent>(_serializer);

  1069.                                     var guild = State.GetGuild(data.GuildId);

  1070.                                     if (guild != null)

  1071.                                     {

  1072.                                         var role = guild.AddRole(data.Role);

  1073. 

  1074.                                         if (!guild.IsSynced)

  1075.                                         {

  1076.                                             await _gatewayLogger.DebugAsync("Ignored GUILD_ROLE_CREATE, guild is not synced yet.").ConfigureAwait(false);

  1077.                                             return;

  1078.                                         }

  1079.                                         await _roleCreatedEvent.InvokeAsync(role).ConfigureAwait(false);

  1080.                                     }

  1081.                                     else

  1082.                                     {

  1083.                                         await _gatewayLogger.WarningAsync("GUILD_ROLE_CREATE referenced an unknown guild.").ConfigureAwait(false);

  1084.                                         return;

  1085.                                     }

  1086.                                 }

  1087.                                 break;

  1088.                             case "GUILD_ROLE_UPDATE":

  1089.                                 {

  1090.                                     await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_ROLE_UPDATE)").ConfigureAwait(false);

  1091. 

  1092.                                     var data = (payload as JToken).ToObject<GuildRoleUpdateEvent>(_serializer);

  1093.                                     var guild = State.GetGuild(data.GuildId);

  1094.                                     if (guild != null)

  1095.                                     {

  1096.                                         var role = guild.GetRole(data.Role.Id);

  1097.                                         if (role != null)

  1098.                                         {

  1099.                                             var before = role.Clone();

  1100.                                             role.Update(State, data.Role);

  1101. 

  1102.                                             if (!guild.IsSynced)

  1103.                                             {

  1104.                                                 await _gatewayLogger.DebugAsync("Ignored GUILD_ROLE_UPDATE, guild is not synced yet.").ConfigureAwait(false);

  1105.                                                 return;

  1106.                                             }

  1107. 

  1108.                                             await _roleUpdatedEvent.InvokeAsync(before, role).ConfigureAwait(false);

  1109.                                         }

  1110.                                         else

  1111.                                         {

  1112.                                             await _gatewayLogger.WarningAsync("GUILD_ROLE_UPDATE referenced an unknown role.").ConfigureAwait(false);

  1113.                                             return;

  1114.                                         }

  1115.                                     }

  1116.                                     else

  1117.                                     {

  1118.                                         await _gatewayLogger.WarningAsync("GUILD_ROLE_UPDATE referenced an unknown guild.").ConfigureAwait(false);

  1119.                                         return;

  1120.                                     }

  1121.                                 }

  1122.                                 break;

  1123.                             case "GUILD_ROLE_DELETE":

  1124.                                 {

  1125.                                     await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_ROLE_DELETE)").ConfigureAwait(false);

  1126. 

  1127.                                     var data = (payload as JToken).ToObject<GuildRoleDeleteEvent>(_serializer);

  1128.                                     var guild = State.GetGuild(data.GuildId);

  1129.                                     if (guild != null)

  1130.                                     {

  1131.                                         var role = guild.RemoveRole(data.RoleId);

  1132.                                         if (role != null)

  1133.                                         {

  1134.                                             if (!guild.IsSynced)

  1135.                                             {

  1136.                                                 await _gatewayLogger.DebugAsync("Ignored GUILD_ROLE_DELETE, guild is not synced yet.").ConfigureAwait(false);

  1137.                                                 return;

  1138.                                             }

  1139. 

  1140.                                             await _roleDeletedEvent.InvokeAsync(role).ConfigureAwait(false);

  1141.                                         }

  1142.                                         else

  1143.                                         {

  1144.                                             await _gatewayLogger.WarningAsync("GUILD_ROLE_DELETE referenced an unknown role.").ConfigureAwait(false);

  1145.                                             return;

  1146.                                         }

  1147.                                     }

  1148.                                     else

  1149.                                     {

  1150.                                         await _gatewayLogger.WarningAsync("GUILD_ROLE_DELETE referenced an unknown guild.").ConfigureAwait(false);

  1151.                                         return;

  1152.                                     }

  1153.                                 }

  1154.                                 break;

  1155. 

  1156.                             //Bans

  1157.                             case "GUILD_BAN_ADD":

  1158.                                 {

  1159.                                     await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_BAN_ADD)").ConfigureAwait(false);

  1160. 

  1161.                                     var data = (payload as JToken).ToObject<GuildBanEvent>(_serializer);

  1162.                                     var guild = State.GetGuild(data.GuildId);

  1163.                                     if (guild != null)

  1164.                                     {

  1165.                                         if (!guild.IsSynced)

  1166.                                         {

  1167.                                             await _gatewayLogger.DebugAsync("Ignored GUILD_BAN_ADD, guild is not synced yet.").ConfigureAwait(false);

  1168.                                             return;

  1169.                                         }

  1170.                                         

  1171.                                         await _userBannedEvent.InvokeAsync(SocketSimpleUser.Create(this, State, data.User), guild).ConfigureAwait(false);

  1172.                                     }

  1173.                                     else

  1174.                                     {

  1175.                                         await _gatewayLogger.WarningAsync("GUILD_BAN_ADD referenced an unknown guild.").ConfigureAwait(false);

  1176.                                         return;

  1177.                                     }

  1178.                                 }

  1179.                                 break;

  1180.                             case "GUILD_BAN_REMOVE":

  1181.                                 {

  1182.                                     await _gatewayLogger.DebugAsync("Received Dispatch (GUILD_BAN_REMOVE)").ConfigureAwait(false);

  1183. 

  1184.                                     var data = (payload as JToken).ToObject<GuildBanEvent>(_serializer);

  1185.                                     var guild = State.GetGuild(data.GuildId);

  1186.                                     if (guild != null)

  1187.                                     {

  1188.                                         if (!guild.IsSynced)

  1189.                                         {

  1190.                                             await _gatewayLogger.DebugAsync("Ignored GUILD_BAN_REMOVE, guild is not synced yet.").ConfigureAwait(false);

  1191.                                             return;

  1192.                                         }

  1193. 

  1194.                                         SocketUser user = State.GetUser(data.User.Id);

  1195.                                         if (user == null)

  1196.                                             user = SocketSimpleUser.Create(this, State, data.User);

  1197.                                         await _userUnbannedEvent.InvokeAsync(user, guild).ConfigureAwait(false);

  1198.                                     }

  1199.                                     else

  1200.                                     {

  1201.                                         await _gatewayLogger.WarningAsync("GUILD_BAN_REMOVE referenced an unknown guild.").ConfigureAwait(false);

  1202.                                         return;

  1203.                                     }

  1204.                                 }

  1205.                                 break;

  1206. 

  1207.                             //Messages

  1208.                             case "MESSAGE_CREATE":

  1209.                                 {

  1210.                                     await _gatewayLogger.DebugAsync("Received Dispatch (MESSAGE_CREATE)").ConfigureAwait(false);

  1211. 

  1212.                                     var data = (payload as JToken).ToObject<API.Message>(_serializer);

  1213.                                     var channel = State.GetChannel(data.ChannelId) as ISocketMessageChannel;

  1214.                                     if (channel != null)

  1215.                                     {

  1216.                                         var guild = (channel as SocketGuildChannel)?.Guild;

  1217.                                         if (guild != null && !guild.IsSynced)

  1218.                                         { 

  1219.                                             await _gatewayLogger.DebugAsync("Ignored MESSAGE_CREATE, guild is not synced yet.").ConfigureAwait(false);

  1220.                                             return;

  1221.                                         }

  1222. 

  1223.                                         SocketUser author;

  1224.                                         if (guild != null)

  1225.                                             author = guild.GetUser(data.Author.Value.Id);

  1226.                                         else

  1227.                                             author = (channel as SocketChannel).GetUser(data.Author.Value.Id);

  1228.                                         if (author == null)

  1229.                                             author = SocketSimpleUser.Create(this, State, data.Author.Value);

  1230. 

  1231.                                         if (author != null)

  1232.                                         {

  1233.                                             var msg = SocketMessage.Create(this, State, author, channel, data);

  1234.                                             SocketChannelHelper.AddMessage(channel, this, msg);

  1235.                                             await _messageReceivedEvent.InvokeAsync(msg).ConfigureAwait(false);

  1236.                                         }

  1237.                                         else

  1238.                                         {

  1239.                                             await _gatewayLogger.WarningAsync("MESSAGE_CREATE referenced an unknown user.").ConfigureAwait(false);

  1240.                                             return;

  1241.                                         }

  1242.                                     }

  1243.                                     else

  1244.                                     {

  1245.                                         await _gatewayLogger.WarningAsync("MESSAGE_CREATE referenced an unknown channel.").ConfigureAwait(false);

  1246.                                         return;

  1247.                                     }

  1248.                                 }

  1249.                                 break;

  1250.                             case "MESSAGE_UPDATE":

  1251.                                 {

  1252.                                     await _gatewayLogger.DebugAsync("Received Dispatch (MESSAGE_UPDATE)").ConfigureAwait(false);

  1253. 

  1254.                                     var data = (payload as JToken).ToObject<API.Message>(_serializer);

  1255.                                     var channel = State.GetChannel(data.ChannelId) as ISocketMessageChannel;

  1256.                                     if (channel != null)

  1257.                                     {

  1258.                                         var guild = (channel as SocketGuildChannel)?.Guild;

  1259.                                         if (guild != null && !guild.IsSynced)

  1260.                                         { 

  1261.                                             await _gatewayLogger.DebugAsync("Ignored MESSAGE_UPDATE, guild is not synced yet.").ConfigureAwait(false);

  1262.                                             return;

  1263.                                         }

  1264. 

  1265.                                         SocketMessage before = null, after = null;

  1266.                                         SocketMessage cachedMsg = channel.GetCachedMessage(data.Id);

  1267.                                         if (cachedMsg != null)

  1268.                                         {

  1269.                                             before = cachedMsg.Clone();

  1270.                                             cachedMsg.Update(State, data);

  1271.                                             after = cachedMsg;

  1272.                                         }

  1273.                                         else if (data.Author.IsSpecified)

  1274.                                         {

  1275.                                             //Edited message isnt in cache, create a detached one

  1276.                                             SocketUser author;

  1277.                                             if (guild != null)

  1278.                                                 author = guild.GetUser(data.Author.Value.Id);

  1279.                                             else

  1280.                                                 author = (channel as SocketChannel).GetUser(data.Author.Value.Id);

  1281.                                             if (author == null)

  1282.                                                 author = SocketSimpleUser.Create(this, State, data.Author.Value);

  1283. 

  1284.                                             after = SocketMessage.Create(this, State, author, channel, data);

  1285.                                         }

  1286.                                         if (before != null)

  1287.                                             await _messageUpdatedEvent.InvokeAsync(before, after).ConfigureAwait(false);

  1288.                                         else

  1289.                                             await _messageUpdatedEvent.InvokeAsync(Optional.Create<SocketMessage>(), after).ConfigureAwait(false);

  1290.                                     }

  1291.                                     else

  1292.                                     {

  1293.                                         await _gatewayLogger.WarningAsync("MESSAGE_UPDATE referenced an unknown channel.").ConfigureAwait(false);

  1294.                                         return;

  1295.                                     }

  1296.                                 }

  1297.                                 break;

  1298.                             case "MESSAGE_DELETE":

  1299.                                 {

  1300.                                     await _gatewayLogger.DebugAsync("Received Dispatch (MESSAGE_DELETE)").ConfigureAwait(false);

  1301.                                     

  1302.                                     var data = (payload as JToken).ToObject<API.Message>(_serializer);

  1303.                                     var channel = State.GetChannel(data.ChannelId) as ISocketMessageChannel;

  1304.                                     if (channel != null)

  1305.                                     {

  1306.                                         if (!((channel as SocketGuildChannel)?.Guild.IsSynced ?? true))

  1307.                                         { 

  1308.                                             await _gatewayLogger.DebugAsync("Ignored MESSAGE_DELETE, guild is not synced yet.").ConfigureAwait(false);

  1309.                                             return;

  1310.                                         }

  1311. 

  1312.                                         var msg = SocketChannelHelper.RemoveMessage(channel, this, data.Id);

  1313.                                         if (msg != null)

  1314.                                             await _messageDeletedEvent.InvokeAsync(data.Id, msg).ConfigureAwait(false);

  1315.                                         else

  1316.                                             await _messageDeletedEvent.InvokeAsync(data.Id, Optional.Create<SocketMessage>()).ConfigureAwait(false);

  1317.                                     }

  1318.                                     else

  1319.                                     {

  1320.                                         await _gatewayLogger.WarningAsync("MESSAGE_DELETE referenced an unknown channel.").ConfigureAwait(false);

  1321.                                         return;

  1322.                                     }

  1323.                                 }

  1324.                                 break;

  1325.                             case "MESSAGE_REACTION_ADD":

  1326.                                 {

  1327.                                     await _gatewayLogger.DebugAsync("Received Dispatch (MESSAGE_REACTION_ADD)").ConfigureAwait(false);

  1328. 

  1329.                                     var data = (payload as JToken).ToObject<API.Gateway.Reaction>(_serializer);

  1330.                                     var channel = State.GetChannel(data.ChannelId) as ISocketMessageChannel;

  1331.                                     if (channel != null)

  1332.                                     {

  1333.                                         SocketUserMessage cachedMsg = channel.GetCachedMessage(data.MessageId) as SocketUserMessage;

  1334.                                         var user = await channel.GetUserAsync(data.UserId, CacheMode.CacheOnly);

  1335.                                         SocketReaction reaction = SocketReaction.Create(data, channel, cachedMsg, Optional.Create(user));

  1336. 

  1337.                                         if (cachedMsg != null)

  1338.                                         {

  1339.                                             cachedMsg.AddReaction(reaction);

  1340.                                             await _reactionAddedEvent.InvokeAsync(data.MessageId, cachedMsg, reaction).ConfigureAwait(false);

  1341.                                             return;

  1342.                                         }

  1343.                                         await _reactionAddedEvent.InvokeAsync(data.MessageId, Optional.Create<SocketUserMessage>(), reaction).ConfigureAwait(false);

  1344.                                     }

  1345.                                     else

  1346.                                     {

  1347.                                         await _gatewayLogger.WarningAsync("MESSAGE_REACTION_ADD referenced an unknown channel.").ConfigureAwait(false);

  1348.                                         return;

  1349.                                     }

  1350.                                     break;

  1351.                                 }

  1352.                             case "MESSAGE_REACTION_REMOVE":

  1353.                                 {

  1354.                                     await _gatewayLogger.DebugAsync("Received Dispatch (MESSAGE_REACTION_REMOVE)").ConfigureAwait(false);

  1355. 

  1356.                                     var data = (payload as JToken).ToObject<API.Gateway.Reaction>(_serializer);

  1357.                                     var channel = State.GetChannel(data.ChannelId) as ISocketMessageChannel;

  1358.                                     if (channel != null)

  1359.                                     {

  1360.                                         SocketUserMessage cachedMsg = channel.GetCachedMessage(data.MessageId) as SocketUserMessage;

  1361.                                         var user = await channel.GetUserAsync(data.UserId, CacheMode.CacheOnly);

  1362.                                         SocketReaction reaction = SocketReaction.Create(data, channel, cachedMsg, Optional.Create(user));

  1363.                                         if (cachedMsg != null)

  1364.                                         {

  1365.                                             cachedMsg.RemoveReaction(reaction);

  1366.                                             await _reactionRemovedEvent.InvokeAsync(data.MessageId, cachedMsg, reaction).ConfigureAwait(false);

  1367.                                             return;

  1368.                                         }

  1369.                                         await _reactionRemovedEvent.InvokeAsync(data.MessageId, Optional.Create<SocketUserMessage>(), reaction).ConfigureAwait(false);

  1370.                                     }

  1371.                                     else

  1372.                                     {

  1373.                                         await _gatewayLogger.WarningAsync("MESSAGE_REACTION_REMOVE referenced an unknown channel.").ConfigureAwait(false);

  1374.                                         return;

  1375.                                     }

  1376.                                     break;

  1377.                                 }

  1378.                             case "MESSAGE_REACTION_REMOVE_ALL":

  1379.                                 {

  1380.                                     await _gatewayLogger.DebugAsync("Received Dispatch (MESSAGE_REACTION_REMOVE_ALL)").ConfigureAwait(false);

  1381. 

  1382.                                     var data = (payload as JToken).ToObject<RemoveAllReactionsEvent>(_serializer);

  1383.                                     var channel = State.GetChannel(data.ChannelId) as ISocketMessageChannel;

  1384.                                     if (channel != null)

  1385.                                     {

  1386.                                         SocketUserMessage cachedMsg = channel.GetCachedMessage(data.MessageId) as SocketUserMessage;

  1387.                                         if (cachedMsg != null)

  1388.                                         {

  1389.                                             cachedMsg.ClearReactions();

  1390.                                             await _reactionsClearedEvent.InvokeAsync(data.MessageId, cachedMsg).ConfigureAwait(false);

  1391.                                             return;

  1392.                                         }

  1393.                                         await _reactionsClearedEvent.InvokeAsync(data.MessageId, Optional.Create<SocketUserMessage>());

  1394.                                     }

  1395.                                     else

  1396.                                     {

  1397.                                         await _gatewayLogger.WarningAsync("MESSAGE_REACTION_REMOVE_ALL referenced an unknown channel.").ConfigureAwait(false);

  1398.                                         return;

  1399.                                     }

  1400. 

  1401.                                     break;

  1402.                                 }

  1403.                             case "MESSAGE_DELETE_BULK":

  1404.                                 {

  1405.                                     await _gatewayLogger.DebugAsync("Received Dispatch (MESSAGE_DELETE_BULK)").ConfigureAwait(false);

  1406. 

  1407.                                     var data = (payload as JToken).ToObject<MessageDeleteBulkEvent>(_serializer);

  1408.                                     var channel = State.GetChannel(data.ChannelId) as ISocketMessageChannel;

  1409.                                     if (channel != null)

  1410.                                     {

  1411.                                         if (!((channel as SocketGuildChannel)?.Guild.IsSynced ?? true))

  1412.                                         {

  1413.                                             await _gatewayLogger.DebugAsync("Ignored MESSAGE_DELETE_BULK, guild is not synced yet.").ConfigureAwait(false);

  1414.                                             return;

  1415.                                         }

  1416. 

  1417.                                         foreach (var id in data.Ids)

  1418.                                         {

  1419.                                             var msg = SocketChannelHelper.RemoveMessage(channel, this, id);

  1420.                                             if (msg != null)

  1421.                                                 await _messageDeletedEvent.InvokeAsync(id, msg).ConfigureAwait(false);

  1422.                                             else

  1423.                                                 await _messageDeletedEvent.InvokeAsync(id, Optional.Create<SocketMessage>()).ConfigureAwait(false);

  1424.                                         }

  1425.                                     }

  1426.                                     else

  1427.                                     {

  1428.                                         await _gatewayLogger.WarningAsync("MESSAGE_DELETE_BULK referenced an unknown channel.").ConfigureAwait(false);

  1429.                                         return;

  1430.                                     }

  1431.                                 }

  1432.                                 break;

  1433. 

  1434.                             //Statuses

  1435.                             case "PRESENCE_UPDATE":

  1436.                                 {

  1437.                                     await _gatewayLogger.DebugAsync("Received Dispatch (PRESENCE_UPDATE)").ConfigureAwait(false);

  1438. 

  1439.                                     var data = (payload as JToken).ToObject<API.Presence>(_serializer);

  1440. 

  1441.                                     if (data.GuildId.IsSpecified)

  1442.                                     {

  1443.                                         var guild = State.GetGuild(data.GuildId.Value);

  1444.                                         if (guild == null)

  1445.                                         {

  1446.                                             await _gatewayLogger.WarningAsync("PRESENCE_UPDATE referenced an unknown guild.").ConfigureAwait(false);

  1447.                                             break;

  1448.                                         }

  1449.                                         if (!guild.IsSynced)

  1450.                                         {

  1451.                                             await _gatewayLogger.DebugAsync("Ignored PRESENCE_UPDATE, guild is not synced yet.").ConfigureAwait(false);

  1452.                                             return;

  1453.                                         }

  1454. 

  1455.                                         SocketPresence beforePresence;

  1456.                                         SocketGlobalUser beforeGlobal;

  1457.                                         var user = guild.GetUser(data.User.Id);

  1458.                                         if (user != null)

  1459.                                         {

  1460.                                             beforePresence = user.Presence.Clone();

  1461.                                             beforeGlobal = user.GlobalUser.Clone();

  1462.                                             user.Update(State, data);

  1463.                                         }

  1464.                                         else

  1465.                                         {

  1466.                                             beforePresence = new SocketPresence(UserStatus.Offline, null);

  1467.                                             user = guild.AddOrUpdateUser(data);

  1468.                                             beforeGlobal = user.GlobalUser.Clone();

  1469.                                         }

  1470. 

  1471.                                         if (data.User.Username.IsSpecified || data.User.Avatar.IsSpecified)

  1472.                                         {

  1473.                                             await _userUpdatedEvent.InvokeAsync(beforeGlobal, user).ConfigureAwait(false);

  1474.                                             return;

  1475.                                         }

  1476.                                         await _userPresenceUpdatedEvent.InvokeAsync(guild, user, beforePresence, user.Presence).ConfigureAwait(false);

  1477.                                     }

  1478.                                     else

  1479.                                     {

  1480.                                         var channel = State.GetChannel(data.User.Id);

  1481.                                         if (channel != null)

  1482.                                         {

  1483.                                             var user = channel.GetUser(data.User.Id);

  1484.                                             var beforePresence = user.Presence.Clone();

  1485.                                             var before = user.GlobalUser.Clone();

  1486.                                             user.Update(State, data);

  1487. 

  1488.                                             await _userPresenceUpdatedEvent.InvokeAsync(Optional.Create<SocketGuild>(), user, beforePresence, user.Presence).ConfigureAwait(false);

  1489.                                             if (data.User.Username.IsSpecified || data.User.Avatar.IsSpecified)

  1490.                                             {

  1491.                                                 await _userUpdatedEvent.InvokeAsync(before, user).ConfigureAwait(false);

  1492.                                             }                                            

  1493.                                         }

  1494.                                     }

  1495.                                 }

  1496.                                 break;

  1497.                             case "TYPING_START":

  1498.                                 {

  1499.                                     await _gatewayLogger.DebugAsync("Received Dispatch (TYPING_START)").ConfigureAwait(false);

  1500. 

  1501.                                     var data = (payload as JToken).ToObject<TypingStartEvent>(_serializer);

  1502.                                     var channel = State.GetChannel(data.ChannelId) as ISocketMessageChannel;

  1503.                                     if (channel != null)

  1504.                                     {

  1505.                                         if (!((channel as SocketGuildChannel)?.Guild.IsSynced ?? true))

  1506.                                         {

  1507.                                             await _gatewayLogger.DebugAsync("Ignored TYPING_START, guild is not synced yet.").ConfigureAwait(false);

  1508.                                             return;

  1509.                                         }

  1510. 

  1511.                                         var user = (channel as SocketChannel).GetUser(data.UserId);

  1512.                                         if (user != null)

  1513.                                             await _userIsTypingEvent.InvokeAsync(user, channel).ConfigureAwait(false);

  1514.                                     }

  1515.                                 }

  1516.                                 break;

  1517. 

  1518.                             //Users

  1519.                             case "USER_UPDATE":

  1520.                                 {

  1521.                                     await _gatewayLogger.DebugAsync("Received Dispatch (USER_UPDATE)").ConfigureAwait(false);

  1522. 

  1523.                                     var data = (payload as JToken).ToObject<API.User>(_serializer);

  1524.                                     if (data.Id == CurrentUser.Id)

  1525.                                     {

  1526.                                         var before = CurrentUser.Clone();

  1527.                                         CurrentUser.Update(State, data);

  1528.                                         await _selfUpdatedEvent.InvokeAsync(before, CurrentUser).ConfigureAwait(false);

  1529.                                     }

  1530.                                     else

  1531.                                     {

  1532.                                         await _gatewayLogger.WarningAsync("Received USER_UPDATE for wrong user.").ConfigureAwait(false);

  1533.                                         return;

  1534.                                     }

  1535.                                 }

  1536.                                 break;

  1537. 

  1538.                             //Voice

  1539.                             case "VOICE_STATE_UPDATE":

  1540.                                 {

  1541.                                     await _gatewayLogger.DebugAsync("Received Dispatch (VOICE_STATE_UPDATE)").ConfigureAwait(false);

  1542. 

  1543.                                     var data = (payload as JToken).ToObject<API.VoiceState>(_serializer);

  1544.                                     if (data.GuildId.HasValue)

  1545.                                     {

  1546.                                         SocketUser user;

  1547.                                         SocketVoiceState before, after;

  1548.                                         if (data.GuildId != null)

  1549.                                         {

  1550.                                             var guild = State.GetGuild(data.GuildId.Value);

  1551.                                             if (guild == null)

  1552.                                             {

  1553.                                                 await _gatewayLogger.WarningAsync("VOICE_STATE_UPDATE referenced an unknown guild.").ConfigureAwait(false);

  1554.                                                 return;

  1555.                                             }

  1556.                                             else if (!guild.IsSynced)

  1557.                                             {

  1558.                                                 await _gatewayLogger.DebugAsync("Ignored VOICE_STATE_UPDATE, guild is not synced yet.").ConfigureAwait(false);

  1559.                                                 return;

  1560.                                             }

  1561. 

  1562.                                             if (data.ChannelId != null)

  1563.                                             {

  1564.                                                 before = guild.GetVoiceState(data.UserId)?.Clone() ?? new SocketVoiceState(null, null, false, false, false);

  1565.                                                 after = guild.AddOrUpdateVoiceState(State, data);

  1566.                                                 if (data.UserId == CurrentUser.Id)

  1567.                                                 {

  1568.                                                     var _ = guild.FinishJoinAudioChannel().ConfigureAwait(false);

  1569.                                                 }

  1570.                                             }

  1571.                                             else

  1572.                                             {

  1573.                                                 before = guild.RemoveVoiceState(data.UserId) ?? new SocketVoiceState(null, null, false, false, false);

  1574.                                                 after = SocketVoiceState.Create(null, data);

  1575.                                             }

  1576. 

  1577.                                             user = guild.GetUser(data.UserId);

  1578.                                         }

  1579.                                         else

  1580.                                         {

  1581.                                             var groupChannel = State.GetChannel(data.ChannelId.Value) as SocketGroupChannel;

  1582.                                             if (groupChannel != null)

  1583.                                             {

  1584.                                                 if (data.ChannelId != null)

  1585.                                                 {

  1586.                                                     before = groupChannel.GetVoiceState(data.UserId)?.Clone() ?? new SocketVoiceState(null, null, false, false, false);

  1587.                                                     after = groupChannel.AddOrUpdateVoiceState(State, data);

  1588.                                                 }

  1589.                                                 else

  1590.                                                 {

  1591.                                                     before = groupChannel.RemoveVoiceState(data.UserId) ?? new SocketVoiceState(null, null, false, false, false);

  1592.                                                     after = SocketVoiceState.Create(null, data);

  1593.                                                 }

  1594.                                                 user = groupChannel.GetUser(data.UserId);

  1595.                                             }

  1596.                                             else

  1597.                                             {

  1598.                                                 await _gatewayLogger.WarningAsync("VOICE_STATE_UPDATE referenced an unknown channel.").ConfigureAwait(false);

  1599.                                                 return;

  1600.                                             }

  1601.                                         }

  1602. 

  1603.                                         if (user != null)

  1604.                                             await _userVoiceStateUpdatedEvent.InvokeAsync(user, before, after).ConfigureAwait(false);

  1605.                                         else

  1606.                                         {

  1607.                                             await _gatewayLogger.WarningAsync("VOICE_STATE_UPDATE referenced an unknown user.").ConfigureAwait(false);

  1608.                                             return;

  1609.                                         }

  1610.                                     }

  1611.                                 }

  1612.                                 break;

  1613.                             case "VOICE_SERVER_UPDATE":

  1614.                                 await _gatewayLogger.DebugAsync("Received Dispatch (VOICE_SERVER_UPDATE)").ConfigureAwait(false);

  1615. 

  1616.                                 if (AudioMode != AudioMode.Disabled)

  1617.                                 {

  1618.                                     var data = (payload as JToken).ToObject<VoiceServerUpdateEvent>(_serializer);

  1619.                                     var guild = State.GetGuild(data.GuildId);

  1620.                                     if (guild != null)

  1621.                                     {

  1622.                                         string endpoint = data.Endpoint.Substring(0, data.Endpoint.LastIndexOf(':'));

  1623.                                         var _ = guild.FinishConnectAudio(_nextAudioId++, endpoint, data.Token).ConfigureAwait(false);

  1624.                                     }

  1625.                                     else

  1626.                                     {

  1627.                                         await _gatewayLogger.WarningAsync("VOICE_SERVER_UPDATE referenced an unknown guild.").ConfigureAwait(false);

  1628.                                         return;

  1629.                                     }

  1630.                                 }

  1631.                                 return;

  1632. 

  1633.                             //Ignored (User only)

  1634.                             case "CHANNEL_PINS_ACK":

  1635.                                 await _gatewayLogger.DebugAsync("Ignored Dispatch (CHANNEL_PINS_ACK)").ConfigureAwait(false);

  1636.                                 break;

  1637.                             case "CHANNEL_PINS_UPDATE":

  1638.                                 await _gatewayLogger.DebugAsync("Ignored Dispatch (CHANNEL_PINS_UPDATE)").ConfigureAwait(false);

  1639.                                 break;

  1640.                             case "GUILD_INTEGRATIONS_UPDATE":

  1641.                                 await _gatewayLogger.DebugAsync("Ignored Dispatch (GUILD_INTEGRATIONS_UPDATE)").ConfigureAwait(false);

  1642.                                 return;

  1643.                             case "MESSAGE_ACK":

  1644.                                 await _gatewayLogger.DebugAsync("Ignored Dispatch (MESSAGE_ACK)").ConfigureAwait(false);

  1645.                                 return;

  1646.                             case "USER_SETTINGS_UPDATE":

  1647.                                 await _gatewayLogger.DebugAsync("Ignored Dispatch (USER_SETTINGS_UPDATE)").ConfigureAwait(false);

  1648.                                 return;

  1649.                             case "WEBHOOKS_UPDATE":

  1650.                                 await _gatewayLogger.DebugAsync("Ignored Dispatch (WEBHOOKS_UPDATE)").ConfigureAwait(false);

  1651.                                 return;

  1652. 

  1653.                             //Others

  1654.                             default:

  1655.                                 await _gatewayLogger.WarningAsync($"Unknown Dispatch ({type})").ConfigureAwait(false);

  1656.                                 return;

  1657.                         }

  1658.                         break;

  1659.                     default:

  1660.                         await _gatewayLogger.WarningAsync($"Unknown OpCode ({opCode})").ConfigureAwait(false);

  1661.                         return;

  1662.                 }

  1663.             }

  1664.             catch (Exception ex)

  1665.             {

  1666.                 await _gatewayLogger.ErrorAsync($"Error handling {opCode}{(type != null ? $" ({type})" : "")}", ex).ConfigureAwait(false);

  1667.                 return;

  1668.             }

  1669.         }

  1670. 

  1671.         private async Task RunHeartbeatAsync(int intervalMillis, CancellationToken cancelToken, Logger logger)

  1672.         {

  1673.             try

  1674.             {

  1675.                 await logger.DebugAsync("Heartbeat Started").ConfigureAwait(false);

  1676.                 while (!cancelToken.IsCancellationRequested)

  1677.                 {

  1678.                     if (_heartbeatTime != 0) //Server never responded to our last heartbeat

  1679.                     {

  1680.                         if (ConnectionState == ConnectionState.Connected && (_guildDownloadTask?.IsCompleted ?? true))

  1681.                         {

  1682.                             await _gatewayLogger.WarningAsync("Server missed last heartbeat").ConfigureAwait(false);

  1683.                             await StartReconnectAsync(new Exception("Server missed last heartbeat")).ConfigureAwait(false);

  1684.                             return;

  1685.                         }

  1686.                     }

  1687.                     _heartbeatTime = Environment.TickCount;

  1688. 

  1689.                     try

  1690.                     {

  1691.                         await ApiClient.SendHeartbeatAsync(_lastSeq).ConfigureAwait(false);

  1692.                     }

  1693.                     catch (Exception ex)

  1694.                     {

  1695.                         await logger.WarningAsync("Heartbeat Errored", ex).ConfigureAwait(false);

  1696.                     }

  1697. 

  1698.                     await Task.Delay(intervalMillis, cancelToken).ConfigureAwait(false);

  1699.                 }

  1700.                 await logger.DebugAsync("Heartbeat Stopped").ConfigureAwait(false);

  1701.             }

  1702.             catch (OperationCanceledException)

  1703.             {

  1704.                 await logger.DebugAsync("Heartbeat Stopped").ConfigureAwait(false);

  1705.             }

  1706.             catch (Exception ex)

  1707.             {

  1708.                 await logger.ErrorAsync("Heartbeat Errored", ex).ConfigureAwait(false);

  1709.             }

  1710.         }

  1711.         private async Task WaitForGuildsAsync(CancellationToken cancelToken, Logger logger)

  1712.         {

  1713.             //Wait for GUILD_AVAILABLEs

  1714.             try

  1715.             {

  1716.                 await logger.DebugAsync("GuildDownloader Started").ConfigureAwait(false);

  1717.                 while ((_unavailableGuilds != 0) && (Environment.TickCount - _lastGuildAvailableTime < 2000))

  1718.                     await Task.Delay(500, cancelToken).ConfigureAwait(false);

  1719.                 await logger.DebugAsync("GuildDownloader Stopped").ConfigureAwait(false);

  1720.             }

  1721.             catch (OperationCanceledException)

  1722.             {

  1723.                 await logger.DebugAsync("GuildDownloader Stopped").ConfigureAwait(false);

  1724.             }

  1725.             catch (Exception ex)

  1726.             {

  1727.                 await logger.ErrorAsync("GuildDownloader Errored", ex).ConfigureAwait(false);

  1728.             }

  1729.         }

  1730.         private async Task SyncGuildsAsync()

  1731.         {

  1732.             var guildIds = Guilds.Where(x => !x.IsSynced).Select(x => x.Id).ToImmutableArray();

  1733.             if (guildIds.Length > 0)

  1734.                 await ApiClient.SendGuildSyncAsync(guildIds).ConfigureAwait(false);

  1735.         }

  1736. 

  1737.         internal SocketGuild AddGuild(ExtendedGuild model, ClientState state)

  1738.         {

  1739.             var guild = SocketGuild.Create(this, state, model);

  1740.             state.AddGuild(guild);

  1741.             if (model.Large)

  1742.                 _largeGuilds.Enqueue(model.Id);

  1743.             return guild;

  1744.         }

  1745.         internal SocketGuild RemoveGuild(ulong id)

  1746.         {

  1747.             var guild = State.RemoveGuild(id);

  1748.             if (guild != null)

  1749.             {

  1750.                 foreach (var channel in guild.Channels)

  1751.                     State.RemoveChannel(id);

  1752.                 foreach (var user in guild.Users)

  1753.                     user.GlobalUser.RemoveRef(this);

  1754.             }

  1755.             return guild;

  1756.         }

  1757. 

  1758.         internal ISocketPrivateChannel AddPrivateChannel(API.Channel model, ClientState state)

  1759.         {

  1760.             var channel = SocketChannel.CreatePrivate(this, state, model);

  1761.             state.AddChannel(channel as SocketChannel);

  1762.             return channel;

  1763.         }

  1764.         internal ISocketPrivateChannel RemovePrivateChannel(ulong id)

  1765.         {

  1766.             var channel = State.RemoveChannel(id) as ISocketPrivateChannel;

  1767.             if (channel != null)

  1768.             {

  1769.                 foreach (var recipient in channel.Recipients)

  1770.                     recipient.GlobalUser.RemoveRef(this);

  1771.             }

  1772.             return channel;

  1773.         }

  1774. 

  1775.         //IDiscordClient

  1776.         DiscordRestApiClient IDiscordClient.ApiClient => ApiClient;

  1777. 

  1778.         Task IDiscordClient.ConnectAsync()

  1779.             => ConnectAsync();

  1780. 

  1781.         async Task<IApplication> IDiscordClient.GetApplicationInfoAsync()

  1782.             => await GetApplicationInfoAsync().ConfigureAwait(false);

  1783. 

  1784.         Task<IChannel> IDiscordClient.GetChannelAsync(ulong id, CacheMode mode)

  1785.             => Task.FromResult<IChannel>(GetChannel(id));

  1786.         Task<IReadOnlyCollection<IPrivateChannel>> IDiscordClient.GetPrivateChannelsAsync(CacheMode mode)

  1787.             => Task.FromResult<IReadOnlyCollection<IPrivateChannel>>(PrivateChannels);

  1788. 

  1789.         async Task<IReadOnlyCollection<IConnection>> IDiscordClient.GetConnectionsAsync()

  1790.             => await GetConnectionsAsync().ConfigureAwait(false);

  1791. 

  1792.         async Task<IInvite> IDiscordClient.GetInviteAsync(string inviteId)

  1793.             => await GetInviteAsync(inviteId).ConfigureAwait(false);

  1794. 

  1795.         Task<IGuild> IDiscordClient.GetGuildAsync(ulong id, CacheMode mode)

  1796.             => Task.FromResult<IGuild>(GetGuild(id));

  1797.         Task<IReadOnlyCollection<IGuild>> IDiscordClient.GetGuildsAsync(CacheMode mode)

  1798.             => Task.FromResult<IReadOnlyCollection<IGuild>>(Guilds);

  1799.         async Task<IGuild> IDiscordClient.CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon)

  1800.             => await CreateGuildAsync(name, region, jpegIcon).ConfigureAwait(false);

  1801. 

  1802.         Task<IUser> IDiscordClient.GetUserAsync(ulong id, CacheMode mode)

  1803.             => Task.FromResult<IUser>(GetUser(id));

  1804.         Task<IUser> IDiscordClient.GetUserAsync(string username, string discriminator)

  1805.             => Task.FromResult<IUser>(GetUser(username, discriminator));

  1806. 

  1807.         Task<IReadOnlyCollection<IVoiceRegion>> IDiscordClient.GetVoiceRegionsAsync()

  1808.             => Task.FromResult<IReadOnlyCollection<IVoiceRegion>>(_voiceRegions.ToReadOnlyCollection());

  1809.         Task<IVoiceRegion> IDiscordClient.GetVoiceRegionAsync(string id)

  1810.             => Task.FromResult<IVoiceRegion>(GetVoiceRegion(id));

  1811.     }

  1812. }
Please read the following content carefully:

Dear OpenI User

Thank you for your continuous support to the Openl Qizhi Community AI Collaboration Platform. In order to protect your usage rights and ensure network security, we updated the Openl Qizhi Community AI Collaboration Platform Usage Agreement in January 2024. The updated agreement specifies that users are prohibited from using intranet penetration tools. After you click "Agree and continue", you can continue to use our services. Thank you for your cooperation and understanding.

For more agreement content, please refer to the《Openl Qizhi Community AI Collaboration Platform Usage Agreement》

Agree and continue
Disagree, exit