using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Oxide.Core;
using Oxide.Core.Libraries.Covalence;
using Oxide.Core.Plugins;
using Oxide.Ext.Discord.Clients;
using Oxide.Ext.Discord.Constants;
using Oxide.Ext.Discord.Entities;
using Oxide.Ext.Discord.Interfaces;
using Oxide.Ext.Discord.Libraries;
using Oxide.Ext.Discord.Logging;

namespace Oxide.Plugins
{
[Info("Discord Team", "MrBlue", "2.0.0")]
[Description("Creates a private voice channel in Discord when creating a team in-game")]
class DiscordTeam : CovalencePlugin, IDiscordPlugin
{
#region Plugin variables
public DiscordClient Client { get; set; }

private Dictionary<string, DiscordChannel> listTeamChannels = new Dictionary<string, DiscordChannel>();
private confData config;
private bool _init;

private readonly GatewayIntents _intents = GatewayIntents.Guilds | GatewayIntents.GuildMembers | GatewayIntents.GuildVoiceStates;

[PluginReference]
private Plugin DiscordLink;

private DiscordGuild _guild;
#endregion

#region Configuration
protected override void LoadDefaultConfig() => Config.WriteObject(new confData(), true);

public class confData
{
[JsonProperty("Discord Bot Token")]
public string Token = string.Empty;

[JsonProperty(PropertyName = "Discord Server ID")]
public Snowflake GuildId { get; set; }

[JsonProperty("Max players in a voice channel")]
public int maxPlayersChannel = 5;

[JsonConverter(typeof(StringEnumConverter))]
[DefaultValue(DiscordLogLevel.Info)]
[JsonProperty(PropertyName = "Discord Extension Log Level")]
public DiscordLogLevel ExtensionDebugging { get; set; } = DiscordLogLevel.Info;
}

protected override void LoadDefaultMessages()
{
lang.RegisterMessages(new Dictionary<string, string>
{
["messageChannelCreated"] = "A private voice channel was created on Discord for your team!",
["channelName"] = "{0}'s Team"
}, this);
}

string GetMessage(string key, string steamId = null) => lang.GetMessage(key, this, steamId);
#endregion

#region Initialization
private void Init() => config = Config.ReadObject<confData>();

private void OnServerInitialized()
{
if (string.IsNullOrEmpty(config.Token))
{
PrintError("Discord Bot Token fehlt in der Config!");
return;
}

if (Client != null) Client.Connect(config.Token, _intents);
}

[HookMethod("OnDiscordGatewayReady")]
private void OnDiscordGatewayReady(GatewayReadyEvent ready)
{
if (Client == null) return;

if (config.GuildId.IsValid())
ready.Guilds.TryGetValue(config.GuildId, out _guild);
else
_guild = ready.Guilds.Values.FirstOrDefault();

if (_guild == null)
{
PrintError("Discord Guild (Server) konnte nicht gefunden werden.");
return;
}

_init = true;
Puts($"✅ Discord Team v2.0.0 (v3.1.0 API) geladen.");
InitializeTeams();
}

private void Unload()
{
if (!_init || Client == null) return;
foreach (var channel in listTeamChannels.Values)
channel.Delete(Client);
listTeamChannels.Clear();
}
#endregion

#region Hooks
// Erstellt Channel wenn ein Team im Spiel erstellt wird
private void OnTeamCreated(BasePlayer player, RelationshipManager.PlayerTeam team)
{
if (player == null) return;
timer.Once(1f, () => CreateChannelForTeam(player));
}

// Löscht Channel wenn das Team aufgelöst wird
private void OnTeamDisbanded(RelationshipManager.PlayerTeam team)
{
if (team == null) return;
string leaderId = team.teamLeader.ToString();
if (listTeamChannels.ContainsKey(leaderId))
{
listTeamChannels[leaderId].Delete(Client);
listTeamChannels.Remove(leaderId);
}
}
#endregion

#region Core Logic
private void CreateChannelForTeam(BasePlayer player)
{
if (player == null || !_init || _guild == null || DiscordLink == null) return;

// Versionsunabhängiger Call an DiscordLink
var result = DiscordLink.Call("GetDiscordId", player.UserIDString);
if (result == null) return;

Snowflake discordId = new Snowflake(result.ToString());
if (!discordId.IsValid()) return;

// Verhindert doppelte Channels
if (listTeamChannels.ContainsKey(player.UserIDString)) return;

var channelName = string.Format(GetMessage("channelName", player.UserIDString), player.displayName);

// FIX für v3.1.0: Wir nutzen CreateChannel der Guild mit explizitem Client
var createData = new ChannelCreate
{
Name = channelName,
Type = ChannelType.GuildVoice,
UserLimit = config.maxPlayersChannel
};

_guild.CreateChannel(Client, createData)
.Then(channel => {
listTeamChannels[player.UserIDString] = channel;
player.ChatMessage(GetMessage("messageChannelCreated", player.UserIDString));
})
.Catch(error => {
PrintError($"Fehler beim Erstellen des Kanals: {error.Message}");
});
}

private void InitializeTeams()
{
foreach (var player in BasePlayer.activePlayerList)
{
if (player != null && player.currentTeam != 0)
{
var team = RelationshipManager.ServerInstance.FindTeam(player.currentTeam);
if (team?.teamLeader.ToString() == player.UserIDString)
{
CreateChannelForTeam(player);
}
}
}
}
#endregion
}
}

 Thank you, config is in English! Seems to work fine, good job!