feat(channels): experimental draft - introduce abstract base channel hierarchy and thread channel abstraction for future channel type splitting/refactor

Co-Authored-By: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>

Author: Lulalaby

DisCatSharp.CommandsNext/CommandsNextExtension.cs

@@ -82,7 +82,7 @@ internal CommandsNextExtension(CommandsNextConfiguration cfg)
 			[typeof(DiscordGuild)] = new DiscordGuildConverter(),
 			[typeof(DiscordMessage)] = new DiscordMessageConverter(),
 			[typeof(DiscordEmoji)] = new DiscordEmojiConverter(),
-			[typeof(DiscordThreadChannel)] = new DiscordThreadChannelConverter(),
+			[typeof(DiscordXThreadChannel)] = new DiscordThreadChannelConverter(),
 			[typeof(DiscordInvite)] = new DiscordInviteConverter(),
 			[typeof(DiscordColor)] = new DiscordColorConverter(),
 			[typeof(DiscordScheduledEvent)] = new DiscordScheduledEventConverter()
@@ -114,7 +114,7 @@ internal CommandsNextExtension(CommandsNextConfiguration cfg)
 			[typeof(DiscordGuild)] = "guild",
 			[typeof(DiscordMessage)] = "message",
 			[typeof(DiscordEmoji)] = "emoji",
-			[typeof(DiscordThreadChannel)] = "thread",
+			[typeof(DiscordXThreadChannel)] = "thread",
 			[typeof(DiscordInvite)] = "invite",
 			[typeof(DiscordColor)] = "color",
 			[typeof(DiscordScheduledEvent)] = "event"

DisCatSharp.CommandsNext/Converters/EntityConverters.cs

@@ -135,14 +135,14 @@ async Task<Optional<DiscordChannel>> IArgumentConverter<DiscordChannel>.ConvertA
 /// <summary>
 ///     Represents a discord thread channel converter.
 /// </summary>
-public class DiscordThreadChannelConverter : IArgumentConverter<DiscordThreadChannel>
+public class DiscordThreadChannelConverter : IArgumentConverter<DiscordXThreadChannel>
 {
 	/// <summary>
 	///     Converts a string.
 	/// </summary>
 	/// <param name="value">The string to convert.</param>
 	/// <param name="ctx">The command context.</param>
-	async Task<Optional<DiscordThreadChannel>> IArgumentConverter<DiscordThreadChannel>.ConvertAsync(string value, CommandContext ctx)
+	async Task<Optional<DiscordXThreadChannel>> IArgumentConverter<DiscordXThreadChannel>.ConvertAsync(string value, CommandContext ctx)
 	{
 		if (ulong.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var tid))
 		{

DisCatSharp/Clients/DiscordClient.Dispatch.cs

@@ -58,7 +58,7 @@ internal async Task HandleDispatchAsync(GatewayPayload payload)
 		ulong uid;
 		DiscordStageInstance stg = default;
 		DiscordIntegration itg = default;
-		DiscordThreadChannel trd = default;
+		DiscordXThreadChannel trd = default;
 		DiscordThreadChannelMember trdm = default;
 		DiscordScheduledEvent gse = default;
 		TransportUser usr = default;
@@ -511,23 +511,23 @@ internal async Task HandleDispatchAsync(GatewayPayload payload)
 #region Thread
 
 			case "thread_create":
-				trd = DiscordJson.DeserializeObject<DiscordThreadChannel>(payloadString, this);
+				trd = DiscordJson.DeserializeObject<DiscordXThreadChannel>(payloadString, this);
 				await this.OnThreadCreateEventAsync(trd).ConfigureAwait(false);
 				break;
 
 			case "thread_update":
-				trd = DiscordJson.DeserializeObject<DiscordThreadChannel>(payloadString, this);
+				trd = DiscordJson.DeserializeObject<DiscordXThreadChannel>(payloadString, this);
 				await this.OnThreadUpdateEventAsync(trd).ConfigureAwait(false);
 				break;
 
 			case "thread_delete":
-				trd = DiscordJson.DeserializeObject<DiscordThreadChannel>(payloadString, this);
+				trd = DiscordJson.DeserializeObject<DiscordXThreadChannel>(payloadString, this);
 				await this.OnThreadDeleteEventAsync(trd).ConfigureAwait(false);
 				break;
 
 			case "thread_list_sync":
 				gid = (ulong)dat["guild_id"]!;
-				var trds = DiscordJson.DeserializeIEnumerableObject<IReadOnlyList<DiscordThreadChannel>>(dat["threads"]!.ToString(), this);
+				var trds = DiscordJson.DeserializeIEnumerableObject<IReadOnlyList<DiscordXThreadChannel>>(dat["threads"]!.ToString(), this);
 				var trms = DiscordJson.DeserializeIEnumerableObject<IReadOnlyList<DiscordThreadChannelMember>>(dat["members"]!.ToString(), this);
 				await this.OnThreadListSyncEventAsync(this.GuildsInternal[gid], dat["channel_ids"]!.ToObject<IReadOnlyList<ulong?>>()!, trds, trms).ConfigureAwait(false);
 				break;
@@ -3258,7 +3258,7 @@ internal async Task OnStageInstanceDeleteEventAsync(DiscordStageInstance stage)
 	///     Handles the thread create event.
 	/// </summary>
 	/// <param name="thread">The created thread.</param>
-	internal async Task OnThreadCreateEventAsync(DiscordThreadChannel thread)
+	internal async Task OnThreadCreateEventAsync(DiscordXThreadChannel thread)
 	{
 		thread.Discord = this;
 		this.InternalGetCachedGuild(thread.GuildId).ThreadsInternal.AddOrUpdate(thread.Id, thread, (oldThread, newThread) => newThread);
@@ -3275,7 +3275,7 @@ internal async Task OnThreadCreateEventAsync(DiscordThreadChannel thread)
 	///     Handles the thread update event.
 	/// </summary>
 	/// <param name="thread">The updated thread.</param>
-	internal async Task OnThreadUpdateEventAsync(DiscordThreadChannel thread)
+	internal async Task OnThreadUpdateEventAsync(DiscordXThreadChannel thread)
 	{
 		if (thread == null)
 			return;
@@ -3284,7 +3284,7 @@ internal async Task OnThreadUpdateEventAsync(DiscordThreadChannel thread)
 		var guild = thread.Guild;
 
 		var threadNew = this.InternalGetCachedThread(thread.Id);
-		DiscordThreadChannel threadOld = null;
+		DiscordXThreadChannel threadOld = null;
 		ThreadUpdateEventArgs updateEvent;
 
 		if (threadNew != null)
@@ -3364,7 +3364,7 @@ internal async Task OnThreadUpdateEventAsync(DiscordThreadChannel thread)
 	///     Handles the thread delete event.
 	/// </summary>
 	/// <param name="thread">The deleted thread.</param>
-	internal async Task OnThreadDeleteEventAsync(DiscordThreadChannel thread)
+	internal async Task OnThreadDeleteEventAsync(DiscordXThreadChannel thread)
 	{
 		if (thread == null)
 			return;
@@ -3391,7 +3391,7 @@ internal async Task OnThreadDeleteEventAsync(DiscordThreadChannel thread)
 	/// <param name="channelIds">The synced channel ids.</param>
 	/// <param name="threads">The synced threads.</param>
 	/// <param name="members">The synced thread members.</param>
-	internal async Task OnThreadListSyncEventAsync(DiscordGuild guild, IReadOnlyList<ulong?> channelIds, IReadOnlyList<DiscordThreadChannel> threads, IReadOnlyList<DiscordThreadChannelMember> members)
+	internal async Task OnThreadListSyncEventAsync(DiscordGuild guild, IReadOnlyList<ulong?> channelIds, IReadOnlyList<DiscordXThreadChannel> threads, IReadOnlyList<DiscordThreadChannelMember> members)
 	{
 		guild.Discord = this;
 

DisCatSharp/Clients/DiscordClient.cs

@@ -839,7 +839,7 @@ public bool TryGetChannel(ulong id, [NotNullWhen(true)] out DiscordChannel? chan
 	/// <exception cref="NotFoundException">Thrown when the thread does not exist.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-	public async Task<DiscordThreadChannel> GetThreadAsync(ulong id, bool fetch = false)
+	public async Task<DiscordXThreadChannel> GetThreadAsync(ulong id, bool fetch = false)
 		=> (fetch ? null : this.InternalGetCachedThread(id)) ?? await this.ApiClient.GetThreadAsync(id).ConfigureAwait(false);
 
 	/// <summary>
@@ -849,7 +849,7 @@ public async Task<DiscordThreadChannel> GetThreadAsync(ulong id, bool fetch = fa
 	/// <param name="thread">The thread, if found.</param>
 	/// <param name="fetch">Whether to ignore the cache. Defaults to true.</param>
 	/// <returns>True if found, otherwise false.</returns>
-	public bool TryGetThread(ulong id, [NotNullWhen(true)] out DiscordThreadChannel? thread, bool fetch = true)
+	public bool TryGetThread(ulong id, [NotNullWhen(true)] out DiscordXThreadChannel? thread, bool fetch = true)
 	{
 		try
 		{
@@ -1474,7 +1474,7 @@ public Task<IReadOnlyList<DiscordSoundboardSound>> ListDefaultSoundboardSoundsAs
 	/// </summary>
 	/// <param name="threadId">The target thread id.</param>
 	/// <returns>The requested thread.</returns>
-	internal DiscordThreadChannel? InternalGetCachedThread(ulong threadId)
+	internal DiscordXThreadChannel? InternalGetCachedThread(ulong threadId)
 	{
 		if (this.GuildsInternal == null || this.GuildsInternal.Count is 0)
 			return null;

DisCatSharp/Entities/Channel/BaseDiscordChannel.cs

@@ -0,0 +1,42 @@
+using System;
+
+using DisCatSharp.Enums;
+
+using Newtonsoft.Json;
+
+namespace DisCatSharp.Entities;
+
+/// <summary>
+/// Represents the base class for all Discord channel types.
+/// </summary>
+public abstract class BaseDiscordChannel : SnowflakeObject, IEquatable<BaseDiscordChannel>
+{
+
+	/// <summary>
+	/// Gets the channel type.
+	/// </summary>
+	[JsonProperty("type")]
+	public ChannelType Type { get; internal set; }
+
+	/// <summary>
+	/// Checks whether this <see cref="BaseDiscordChannel" /> is equal to another <see cref="BaseDiscordChannel" />.
+	/// </summary>
+	public bool Equals(BaseDiscordChannel other)
+		=> other is not null && (ReferenceEquals(this, other) || this.Id == other.Id);
+
+	public override bool Equals(object obj)
+		=> this.Equals(obj as BaseDiscordChannel);
+
+	public override int GetHashCode()
+		=> this.Id.GetHashCode();
+
+	public static bool operator ==(BaseDiscordChannel e1, BaseDiscordChannel e2)
+	{
+		var o1 = e1 as object;
+		var o2 = e2 as object;
+		return (o1 != null || o2 == null) && (o1 == null || o2 != null) && ((o1 == null && o2 == null) || e1.Id == e2.Id);
+	}
+
+	public static bool operator !=(BaseDiscordChannel e1, BaseDiscordChannel e2)
+		=> !(e1 == e2);
+}

DisCatSharp/Entities/Channel/DiscordChannel.cs

@@ -1273,7 +1273,7 @@ public async Task<DiscordScheduledEvent> CreateScheduledEventAsync(string name,
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
 	/// <exception cref="NotSupportedException">Thrown when a wrong <paramref name="type" /> was given.</exception>
-	public async Task<DiscordThreadChannel> CreateThreadAsync(string name, ThreadAutoArchiveDuration autoArchiveDuration = ThreadAutoArchiveDuration.OneHour, ChannelType type = ChannelType.PublicThread, int? rateLimitPerUser = null, string reason = null) =>
+	public async Task<DiscordXThreadChannel> CreateThreadAsync(string name, ThreadAutoArchiveDuration autoArchiveDuration = ThreadAutoArchiveDuration.OneHour, ChannelType type = ChannelType.PublicThread, int? rateLimitPerUser = null, string reason = null) =>
 		type != ChannelType.NewsThread && type != ChannelType.PublicThread && type != ChannelType.PrivateThread
 			? throw new NotSupportedException("Wrong thread type given.")
 			: !this.IsThreadHolder()
@@ -1300,7 +1300,7 @@ public async Task<DiscordThreadChannel> CreateThreadAsync(string name, ThreadAut
 	/// <exception cref="NotFoundException">Thrown when the guild hasn't enabled threads atm.</exception>
 	/// <exception cref="BadRequestException">Thrown when an invalid parameter was provided.</exception>
 	/// <exception cref="ServerErrorException">Thrown when Discord is unable to process the request.</exception>
-	public async Task<DiscordThreadChannel> CreatePostAsync(string name, DiscordMessageBuilder builder, int? rateLimitPerUser = null, IEnumerable<ForumPostTag>? tags = null, string reason = null)
+	public async Task<DiscordXThreadChannel> CreatePostAsync(string name, DiscordMessageBuilder builder, int? rateLimitPerUser = null, IEnumerable<ForumPostTag>? tags = null, string reason = null)
 		=> this.Type != ChannelType.Forum ? throw new NotSupportedException("Parent channel must be forum.") : await this.Discord.ApiClient.CreateThreadAsync(this.Id, null, name, null, null, rateLimitPerUser, tags, builder, true, reason).ConfigureAwait(false);
 
 	/// <summary>

DisCatSharp/Entities/Channel/DiscordChannelConverter.cs

@@ -0,0 +1,66 @@
+/*using System;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using DisCatSharp.Enums;
+
+namespace DisCatSharp.Entities
+{
+    /// <summary>
+    /// Polymorphic converter for Discord channel types.
+    /// </summary>
+    public class DiscordChannelConverter : JsonConverter<BaseDiscordChannel>
+    {
+        public override BaseDiscordChannel ReadJson(JsonReader reader, Type objectType, BaseDiscordChannel existingValue, bool hasExistingValue, JsonSerializer serializer)
+        {
+            var jo = JObject.Load(reader);
+            var type = (ChannelType)jo["type"].Value<int>();
+            BaseDiscordChannel channel;
+            switch (type)
+            {
+                case ChannelType.Private:
+                    channel = new DiscordDmChannel();
+                    break;
+                case ChannelType.Group:
+                    channel = new DiscordGroupDmChannel();
+                    break;
+                case ChannelType.Text:
+                    channel = new DiscordTextChannel();
+                    break;
+                case ChannelType.News:
+                    channel = new DiscordAnnouncementChannel();
+                    break;
+                case ChannelType.Forum:
+                    channel = new DiscordForumChannel();
+                    break;
+                case ChannelType.Media:
+                    channel = new DiscordMediaChannel();
+                    break;
+                case ChannelType.PublicThread:
+                case ChannelType.PrivateThread:
+                case ChannelType.NewsThread:
+                    channel = new DiscordThreadChannel();
+                    break;
+                case ChannelType.Voice:
+                    channel = new DiscordVoiceChannel();
+                    break;
+                case ChannelType.Stage:
+                    channel = new DiscordStageChannel();
+                    break;
+                case ChannelType.Category:
+                    channel = new DiscordCategoryChannel();
+                    break;
+                default:
+                    channel = new DiscordChannel(); // fallback
+                    break;
+            }
+            serializer.Populate(jo.CreateReader(), channel);
+            return channel;
+        }
+
+        public override void WriteJson(JsonWriter writer, BaseDiscordChannel value, JsonSerializer serializer)
+        {
+            serializer.Serialize(writer, value);
+        }
+    }
+}
+*/

DisCatSharp/Entities/Channel/DiscordGuildChannel.cs

@@ -0,0 +1,45 @@
+using Newtonsoft.Json;
+
+namespace DisCatSharp.Entities;
+
+/// <summary>
+/// Represents a base class for all guild channels.
+/// </summary>
+public abstract class DiscordGuildChannel : BaseDiscordChannel
+{
+	/// <summary>
+	/// Gets the guild id this channel belongs to.
+	/// </summary>
+	[JsonProperty("guild_id", NullValueHandling = NullValueHandling.Ignore)]
+	public ulong? GuildId { get; internal set; }
+
+	/// <summary>
+	/// Gets the channel name.
+	/// </summary>
+	[JsonProperty("name", NullValueHandling = NullValueHandling.Ignore)]
+	public string Name { get; internal set; }
+
+	/// <summary>
+	/// Gets the channel position.
+	/// </summary>
+	[JsonProperty("position", NullValueHandling = NullValueHandling.Ignore)]
+	public int? Position { get; internal set; }
+
+	/// <summary>
+	/// Gets the permission overwrites for this channel.
+	/// </summary>
+	[JsonProperty("permission_overwrites", NullValueHandling = NullValueHandling.Ignore)]
+	public object[] PermissionOverwrites { get; internal set; } // Replace object with actual type
+
+	/// <summary>
+	/// Gets the parent category id.
+	/// </summary>
+	[JsonProperty("parent_id", NullValueHandling = NullValueHandling.Ignore)]
+	public ulong? ParentId { get; internal set; }
+
+	/// <summary>
+	/// Gets the channel flags.
+	/// </summary>
+	[JsonProperty("flags", NullValueHandling = NullValueHandling.Ignore)]
+	public int? Flags { get; internal set; }
+}

DisCatSharp/Entities/Channel/DiscordGuildTextChannel.cs

@@ -0,0 +1,33 @@
+using Newtonsoft.Json;
+
+namespace DisCatSharp.Entities;
+
+/// <summary>
+/// Represents a base class for all guild text-based channels.
+/// </summary>
+public abstract class DiscordGuildTextChannel : DiscordGuildChannel
+{
+	/// <summary>
+	/// Gets the channel topic.
+	/// </summary>
+	[JsonProperty("topic", NullValueHandling = NullValueHandling.Ignore)]
+	public string Topic { get; internal set; }
+
+	/// <summary>
+	/// Gets the last message id in the channel.
+	/// </summary>
+	[JsonProperty("last_message_id", NullValueHandling = NullValueHandling.Ignore)]
+	public ulong? LastMessageId { get; internal set; }
+
+	/// <summary>
+	/// Gets the rate limit per user (slowmode).
+	/// </summary>
+	[JsonProperty("rate_limit_per_user", NullValueHandling = NullValueHandling.Ignore)]
+	public int? RateLimitPerUser { get; internal set; }
+
+	/// <summary>
+	/// Gets the nsfw status.
+	/// </summary>
+	[JsonProperty("nsfw", NullValueHandling = NullValueHandling.Ignore)]
+	public bool? IsNsfw { get; internal set; }
+}

DisCatSharp/Entities/Channel/DiscordGuildVoiceChannel.cs

@@ -0,0 +1,33 @@
+using Newtonsoft.Json;
+
+namespace DisCatSharp.Entities;
+
+/// <summary>
+/// Represents a base class for all guild voice-based channels.
+/// </summary>
+public abstract class DiscordGuildVoiceChannel : DiscordGuildChannel
+{
+	/// <summary>
+	/// Gets the bitrate (in bits) of the voice channel.
+	/// </summary>
+	[JsonProperty("bitrate", NullValueHandling = NullValueHandling.Ignore)]
+	public int? Bitrate { get; internal set; }
+
+	/// <summary>
+	/// Gets the user limit of the voice channel.
+	/// </summary>
+	[JsonProperty("user_limit", NullValueHandling = NullValueHandling.Ignore)]
+	public int? UserLimit { get; internal set; }
+
+	/// <summary>
+	/// Gets the voice region id (deprecated, but present in API).
+	/// </summary>
+	[JsonProperty("rtc_region", NullValueHandling = NullValueHandling.Ignore)]
+	public string RtcRegion { get; internal set; }
+
+	/// <summary>
+	/// Gets the video quality mode.
+	/// </summary>
+	[JsonProperty("video_quality_mode", NullValueHandling = NullValueHandling.Ignore)]
+	public int? VideoQualityMode { get; internal set; }
+}