import discord
from discord.ext import commands, tasks
from discord import app_commands
from datetime import datetime
from zoneinfo import ZoneInfo
import asyncio
import discord
from discord.ui import Button, View
import pytz
import requests
import os
import xml.etree.ElementTree as ET
import re

# --- CONFIGURATION ---


# Kanal, in dem das Auswahl-Embed regelmäßig gepostet wird
TICKET_CHANNEL_ID = 1445171142095536250

# Definition der Ticket-Kategorien
# channel_prefix: Name des Ticket-Channels
# role_id: Rolle, die Zugriff und Ping erhält
# discord_category_id: ID der Discord-Kategorie, in der das Ticket erstellt wird
# Ticket-Kategorien konfigurieren (mit prefix, Rolle, Kategorie-ID)
TICKET_CATEGORIES = {
    "Supportanfrage": {
        "channel_prefix": "support",
        "role_id": 1445171945942417408,
        "discord_category_id": 1445173917118627950,
        "emoji": "❓",
        "description": "Allgemeiner Supportbereich"
    },
    "Anliegen": {
        "channel_prefix": "anliegen",
        "role_id": 1445171945942417408,
        "discord_category_id": 1445174068499321047,
        "emoji": "📃",
        "description": "Anliegen an das Serverteam"
    },
    "Streamer": {
        "channel_prefix": "streamer",
        "role_id": 1445171945942417408,
        "discord_category_id": 1445174169057624104,
        "emoji": "🎥",
        "description": "Streamerlizenz beantragen"
    }
}


# --- BOT SETUP ---

intents = discord.Intents.default()
intents.members = True
intents.message_content = True

bot = commands.Bot(command_prefix="/", intents=intents)

status_index = 0  # Welcher Status gerade aktiv ist



@tasks.loop(seconds=60)  # alle 60 Sekunden wechseln – kannst du anpassen
async def rotate_status():
    global status_index

    if status_index == 0:
        # Status 1: Spielt Support • /help
        await bot.change_presence(
            activity=discord.Game(name="Support • /help"),
            status=discord.Status.online
        )
        status_index = 1
    else:
        # Status 2: Schaut AetherionCraft auf YouTube
        await bot.change_presence(
            activity=discord.Activity(
                type=discord.ActivityType.watching,
                name="AetherionCraft auf YouTube"
            ),
            status=discord.Status.online
        )
     
        status_index = 0
        
@bot.event
async def on_ready():
    await bot.tree.sync()
    print(f"✅ Eingeloggt als {bot.user}")
    await bot.change_presence(activity=discord.Game(name="Support • /help"), status=discord.Status.online)

    auto_update_ticket_embed.start()
    update_status_loop.start()
    check_youtube.start()
    rotate_status.start()

    guild = bot.get_guild(GUILD_ID)
    if guild:
        await send_login_embed(guild)  # ❗️nur Login-Embed hier, KEIN update_status_embed mehr


  
# --- EMBED FÜR TICKET-AUSWAHL ---

def create_ticket_embed():
    embed = discord.Embed(
        title="Supportanfrage – AetherionCraft",
        color=discord.Color.from_str("#0011FF")
    )
    
    embed.set_footer(text="AetherionCraft-Support", icon_url="")
    
    embed.set_image(url="https://cdn.discordapp.com/attachments/1342520581203169380/1393740240627175464/Supportbereich_1.png?ex=6874453f&is=6872f3bf&hm=c2c0792c2a860cb43e8cab2c469f59e564f8dd4d5718d6eebcc4ea01bd076a66&")

    embed.add_field(
        name="🌟 Willkommen im Supportbereich",
        value=(
            "Schön, dass du hier bist! Unser Team steht dir jederzeit zur Verfügung, "
            "um dir bei deinen Anliegen schnell und zuverlässig zu helfen."
        ),
        inline=False
    )
    embed.add_field(
        name="🎫 So funktioniert unser Ticketsystem",
        value=(
            "1️⃣ **Wähle den passenden Reiter (Kategorie)** für dein Anliegen aus dem Menü unten aus.\n"
            "➡️ So wird dein Ticket direkt an das zuständige Team weitergeleitet.\n\n"
            "2️⃣ **Beschreibe dein Anliegen möglichst genau und verständlich.**\n"
            "Je mehr Informationen du gibst, desto besser können wir dir helfen.\n\n"
            "3️⃣ **Wir bearbeiten die Tickets in der Reihenfolge ihres Eingangs.**\n"
            "Bitte habe etwas Geduld, falls es mal etwas länger dauert."
        ),
        inline=False
    )
    embed.add_field(
        name="🤝 Unser Umgang miteinander",
        value=(
            "Respekt und Freundlichkeit sind uns sehr wichtig:\n"
            "• Bitte bleibe stets höflich und freundlich im Umgang mit unserem Team.\n"
            "• Beleidigungen oder unangemessenes Verhalten können zur Schließung deines Tickets führen."
        ),
        inline=False
    )
    embed.add_field(
        name="🔒 Datenschutz & Privatsphäre",
        value=(
            "Deine Tickets sind vertraulich und nur für dich und das Zuständige Support-Team sichtbar.\n"
            "Wir gehen sorgfältig mit deinen Daten um und geben sie nicht an Dritte weiter."
        ),
        inline=False
    )
    embed.add_field(
        name="⏳ Wartezeiten & Bearbeitung",
        value=(
            "Je nach Anzahl der offenen Tickets kann die Bearbeitungszeit variieren.\n"
            "Wir geben unser Bestes, um dir so schnell wie möglich zu antworten.\n"
            "Sollte sich dein Problem ändern, kannst du uns jederzeit ein Update senden."
        ),
        inline=False
    )
    embed.add_field(
        name="💙 Vielen Dank für dein Vertrauen!",
        value="Wir freuen uns, dich unterstützen zu dürfen. Dein AetherionCraft-Team steht dir jederzeit zur Seite.",
        inline=False
    )

    return embed

# --- KATEGORIE-SPEZIFISCHE EMBEDS ---

def get_ticket_open_embed(category: str, user: discord.Member) -> discord.Embed:
    e = discord.Embed(color=discord.Color.from_str("#0011FF"))
    e.set_footer(text="Support-Team • Bitte bleib freundlich 😊")

    if category == "Supportanfrage":
        e.title = "📨 Support-Ticket"
        e.description = (
            f"Hallo {user.mention}!\n\n"
            "👋 Willkommen beim allgemeinen Support.\n"
            "Bitte beschreibe dein Problem so genau wie möglich, damit wir dir schnell helfen können."
        )

    elif category == "Anliegen":
        e.title = "📝 Anliegen-Ticket"
        e.description = (
            f"Hallo {user.mention}!\n\n"
            "Bitte schildere dein Anliegen ausführlich, damit das zuständige Team es prüfen kann."
        )

    elif category == "Streamer":
        e.title = "🎥 Streamer-Anfrage"
        e.description = (
            f"Hey {user.mention}!\n\n"
            "Du möchtest Streamer bei AetherionCrafts Discord werden? Gib bitte folgende Infos an:\n"
            "- Link zu deinem Kanal\n"
            "- Streaming-Zeiten\n"
            "- Warum du auf AetherionCraft streamen möchtest"
        )

    else:
        e.title = "📨 Neues Ticket"
        e.description = (
            f"Hallo {user.mention}, dein Ticket wurde erstellt.\n"
            "Bitte schildere dein Anliegen möglichst genau."
        )

    return e

# --- UI-Elemente ---

class TicketCategorySelect(discord.ui.Select):
    def __init__(self):
        options = [
            discord.SelectOption(
                label="Supportanfrage",
                value="Supportanfrage",
                description="Allgemeiner Supportbereich",
                emoji="❓"
            ),
            discord.SelectOption(
                label="Anliegen",
                value="Anliegen",
                description="Anliegen an das Serverteam",
                emoji="📃"
            ),
            discord.SelectOption(
                label="Streamer",
                value="Streamer",
                description="Streamerlizenz beantragen",
                emoji="🎥"
            ),
        ]
        super().__init__(
            placeholder="Wähle deine Ticket-Kategorie...",
            min_values=1,
            max_values=1,
            options=options,
            custom_id="ticket_category_select"
        )

            
        
        super().__init__(
            placeholder="Wähle deine Ticket-Kategorie...",
            min_values=1,
            max_values=1,
            options=options,
            custom_id="ticket_category_select"
        )

    async def callback(self, interaction: discord.Interaction):
        user = interaction.user
        guild = interaction.guild
        selected = self.values[0]
        data = TICKET_CATEGORIES[selected]

        # Rolle & Kategorie-Channel holen
        role = guild.get_role(data["role_id"])
        cat = guild.get_channel(data["discord_category_id"])
        if not role or not isinstance(cat, discord.CategoryChannel):
            await interaction.response.send_message("⚠️ Konfiguration fehlt: Rolle oder Kategorie nicht gefunden.", ephemeral=True)
            return

        # Channel-Name bauen
        ts = datetime.now(ZoneInfo("Europe/Berlin")).strftime("%H%M%S")
        name = f"{data['channel_prefix']}-{user.name}-{ts}".lower()

        # Permissions
        overwrites = {
            guild.default_role: discord.PermissionOverwrite(read_messages=False),
            user: discord.PermissionOverwrite(read_messages=True, send_messages=True),
            role: discord.PermissionOverwrite(read_messages=True, send_messages=True)
        }

        # Channel erstellen
        channel = await guild.create_text_channel(name=name, category=cat, overwrites=overwrites)

        # Erstes, kategorie-spezifisches Embed
        embed = get_ticket_open_embed(selected, user)
        view = CloseTicketView(channel, user)
        await channel.send(content=f"{user.mention} {role.mention}", embed=embed, view=view)

        # Auswahl-Embed updaten & Bestätigung
        await interaction.response.edit_message(embed=create_ticket_embed(), view=TicketCategorySelectView())
        await interaction.followup.send(f"✅ Dein Ticket wurde erstellt: {channel.mention}", ephemeral=True)

class TicketCategorySelectView(discord.ui.View):
    def __init__(self):
        super().__init__(timeout=None)
        self.add_item(TicketCategorySelect())

class CloseTicketView(discord.ui.View):
    def __init__(self, channel: discord.TextChannel, owner: discord.Member):
        super().__init__(timeout=None)
        self.channel = channel
        self.owner = owner

    @discord.ui.button(label="🗑️ Ticket schließen", style=discord.ButtonStyle.danger)
    async def close_button(self, interaction: discord.Interaction, button: discord.ui.Button):
        if interaction.user != self.owner and not interaction.user.guild_permissions.manage_channels:
            await interaction.response.send_message("🚫 Du darfst dieses Ticket nicht schließen.", ephemeral=True)
            return

        await interaction.response.send_message("📌 Ticket wird in 5 Sekunden geschlossen...", ephemeral=True)
        # DM an den Ersteller
        try:
            dm = discord.Embed(
                title="Dein Ticket wurde geschlossen",
                description="Danke für dein Vertrauen! Bei neuen Fragen erstelle einfach ein neues Ticket. 💙",
                color=discord.Color.from_str("#0011FF")
            )
            await self.owner.send(embed=dm)
        except discord.Forbidden:
            pass

        await asyncio.sleep(5)
        await self.channel.delete()

# --- Periodisches Embed-Update ---

ticket_message: discord.Message | None = None

@tasks.loop(minutes=10)
async def auto_update_ticket_embed():
    global ticket_message
    chan = bot.get_channel(TICKET_CHANNEL_ID)
    if not isinstance(chan, discord.TextChannel):
        print("❌ Ticket-Channel nicht gefunden")
        return

    embed = create_ticket_embed()
    view = TicketCategorySelectView()

    try:
        if ticket_message:
            await ticket_message.edit(embed=embed, view=view)
            print("♻️ Ticket-Embed aktualisiert")
        else:
            ticket_message = await chan.send(embed=embed, view=view)
            print("✅ Ticket-Embed gepostet")
    except discord.NotFound:
        ticket_message = await chan.send(embed=embed, view=view)
        print("♻️ Embed neu gesendet")


# === KONFIGURATION ===
GUILD_ID = 1438214282180296867
SUPPORT_ROLE_ID = 1445171945942417408
STATUS_CHANNEL_ID = 1445172329868165220  # Öffentlich
LOGIN_CHANNEL_ID = 1445172679333122190   # Nur für Teammitglieder

# === STATUS-VARIABLEN ===
support_online = set()
status_message = None
login_message = None
ticket_status = "```🟢 Online```"

def build_status_embed(guild):
    now = datetime.now(pytz.timezone("Europe/Berlin")).strftime("%d.%m.%Y %H:%M:%S")
    members = [guild.get_member(uid) for uid in support_online]
    mentions = [m.mention for m in members if m is not None]

    if mentions:
        support_status = "```🟢 Verfügbar```"
        support_field = ", ".join(mentions)
        color = discord.Color.blue()
    else:
        support_status = "```🔴 Nicht verfügbar```"
        support_field = "```❌ Keine Teammitglieder verfügbar```"
        color = discord.Color.from_str("#0011FF")

    embed = create_status_embed(now, support_status, support_field, ticket_status, color)
    return embed


def create_status_embed(now, support_status, support_field, ticket_status, color):
    embed = discord.Embed(title="", color=color)
    embed.add_field(name="📅 LETZTE AKTUALISIERUNG", value=now, inline=False)
    embed.add_field(name="SUPPORT STATUS", value=support_status, inline=False)
    embed.add_field(name="VERFÜGBARES SUPPORT-TEAM", value=support_field, inline=False)
    embed.add_field(name="TICKET SYSTEM STATUS", value=ticket_status, inline=False)
    embed.set_thumbnail(url="")
    embed.set_author(
        name="AetherionCraft Support System",
        icon_url=""
    )
    embed.set_image(url="")
    embed.set_footer(text="🔁 Aktualisierung alle 10 Minuten | Für sofortige Hilfe bitte ein Support-Ticket eröffnen")
    return embed


# === Buttons für Login / Logout ===
class SupportLoginView(View):
    def __init__(self):
        super().__init__(timeout=None)

    @discord.ui.button(label="Anmelden", style=discord.ButtonStyle.success)
    async def login(self, interaction: discord.Interaction, button: Button):
        if SUPPORT_ROLE_ID not in [role.id for role in interaction.user.roles]:
            await interaction.response.send_message("⛔ Du bist kein Teammitglied.", ephemeral=True)
            return

        support_online.add(interaction.user.id)
        await interaction.response.send_message(f"✅ {interaction.user.mention} Du hast dich Angemeldet.", ephemeral=True)
        await update_status_embed(interaction.guild)

    @discord.ui.button(label="Abmelden", style=discord.ButtonStyle.danger)
    async def logout(self, interaction: discord.Interaction, button: Button):
        if interaction.user.id not in support_online:
            await interaction.response.send_message("❗ Du bist nicht Angemeldet.", ephemeral=True)
            return

        support_online.remove(interaction.user.id)
        await interaction.response.send_message(f"👋 {interaction.user.mention} Erfolgreich Abgemeldet.", ephemeral=True)
        await update_status_embed(interaction.guild)

# === Öffentlicher Embed aktualisieren ===
async def update_status_embed(guild: discord.Guild):
    global status_message
    channel = guild.get_channel(STATUS_CHANNEL_ID)
    if not channel:
        return

    embed = build_status_embed(guild)

    if status_message:
        try:
            await status_message.edit(embed=embed)
        except discord.NotFound:
            status_message = await channel.send(embed=embed)
    else:
        status_message = await channel.send(embed=embed)

# === Login-Embed mit Buttons (nur Teamchannel) ===
async def send_login_embed(guild: discord.Guild):
    global login_message
    channel = guild.get_channel(LOGIN_CHANNEL_ID)
    if not channel:
        return

    embed = discord.Embed(
        title="Support-Stempeluhr",
        description=(
            "🕐 **Bitte melde dich an**, sobald du für den Support verfügbar bist.\n"
            "🚫 Wenn du keinen Support mehr leisten möchtest, **melde dich bitte wieder ab**.\n\n"
            "Dies hilft uns, den aktuellen Support-Status transparent zu halten."
        ),
        color=discord.Color.from_str("#0011FF")
    )

    # Optional: Zeitstempel hinzufügen
    now = datetime.now(pytz.timezone("Europe/Berlin")).strftime("%d.%m.%Y %H:%M:%S")
    embed.set_footer(text=f"⏱️ Letzte Aktualisierung: {now}")
    embed.set_image(url="")

    if login_message:
        try:
            await login_message.edit(embed=embed, view=SupportLoginView())
        except discord.NotFound:
            login_message = await channel.send(embed=embed, view=SupportLoginView())
    else:
        login_message = await channel.send(embed=embed, view=SupportLoginView())


# === Periodische Aktualisierung ===
@tasks.loop(minutes=10)
async def update_status_loop():
    guild = bot.get_guild(GUILD_ID)
    if guild:
        await update_status_embed(guild)


# === Manuelles Senden (Admin Befehl) ===
@bot.command()
async def supportlogin(ctx):
    if SUPPORT_ROLE_ID not in [role.id for role in ctx.author.roles]:
        await ctx.send("⛔ Du hast keine Berechtigung.")
        return

    embed = discord.Embed(
        title="🔐 Support Login",
        description="Bitte logge dich hier ein oder aus.",
        color=discord.Color.from_str("#0011FF")
    )
    await ctx.send(embed=embed, view=SupportLoginView())

YOUTUBE_ANNOUNCE_CHANNEL_ID = 1438486637440008232     # Discord-Channel, wo die Nachricht rein soll
YOUTUBE_CHANNEL_ID = "UCtMmJd6RH-u4Q8MPha5WRzw"       # Deine YouTube Channel-ID
CHECK_INTERVAL_SECONDS = 60                           # alle X Sekunden prüfen
CHANNEL_NAME_OVERRIDE = ""                            # optional fester Name, z.B. "Mr.GamingDC"

LAST_ID_FILE = "last_video_id.txt"

ATOM_NS = {
    "atom": "http://www.w3.org/2005/Atom",
    "yt": "http://www.youtube.com/xml/schemas/2015",
}

# Cache im RAM, damit auch ohne Datei kein Doppelspam entsteht
announced_ids_cache: set[str] = set()


# =========================
# HILFSFUNKTIONEN
# =========================

def load_announced_video_ids() -> set[str]:
    """
    Liest alle bereits angekündigten Video-IDs aus der Datei.
    Jede Zeile = eine Video-ID.
    """
    if not os.path.exists(LAST_ID_FILE):
        return set()
    with open(LAST_ID_FILE, "r", encoding="utf-8") as f:
        return {line.strip() for line in f.readlines() if line.strip()}


def save_announced_video_id(video_id: str):
    """
    Hängt eine neue Video-ID an die Datei an.
    So wird dasselbe Video nach Neustart nicht nochmal angekündigt.
    """
    with open(LAST_ID_FILE, "a", encoding="utf-8") as f:
        f.write(video_id + "\n")


def get_channel_name(root, entry):
    """Ermittelt den Kanalnamen möglichst zuverlässig."""
    if CHANNEL_NAME_OVERRIDE:
        return CHANNEL_NAME_OVERRIDE

    author = entry.find("atom:author/atom:name", ATOM_NS)
    if author is not None and author.text:
        return author.text

    author = root.find("atom:author/atom:name", ATOM_NS)
    if author is not None and author.text:
        return author.text

    return "YouTube Kanal"


def extract_video_id_from_url(url: str):
    """
    Extrahiert eine YouTube-Video-ID aus verschiedenen Link-Formaten:
    - https://www.youtube.com/watch?v=XXXXXXXXXXX
    - https://youtu.be/XXXXXXXXXXX
    - https://www.youtube.com/shorts/XXXXXXXXXXX
    """
    patterns = [
        r"v=([A-Za-z0-9_-]{11})",
        r"youtu\.be/([A-Za-z0-9_-]{11})",
        r"shorts/([A-Za-z0-9_-]{11})",
    ]
    for p in patterns:
        match = re.search(p, url)
        if match:
            return match.group(1)
    return None


def fetch_video_info_by_id(video_id: str):
    """
    Holt Videodaten (Titel, Link, Kanal) aus dem RSS-Feed für eine bestimmte Video-ID.
    (z.B. für Test-Commands nutzbar)
    """
    feed = f"https://www.youtube.com/feeds/videos.xml?channel_id={YOUTUBE_CHANNEL_ID}"
    r = requests.get(feed, timeout=10)
    r.raise_for_status()

    root = ET.fromstring(r.text)
    entries = root.findall("atom:entry", ATOM_NS)

    for entry in entries:
        vid = entry.find("yt:videoId", ATOM_NS)
        if vid is not None and vid.text == video_id:
            title = entry.find("atom:title", ATOM_NS).text
            link = entry.find("atom:link", ATOM_NS).get("href")
            channel_name = get_channel_name(root, entry)
            return {
                "id": video_id,
                "title": title,
                "url": link,
                "channel_name": channel_name,
            }

    return None


def fetch_latest_video():
    """
    Holt das neueste Video/Short aus dem RSS-Feed.
    Wird vom Auto-Checker benutzt.
    """
    url = f"https://www.youtube.com/feeds/videos.xml?channel_id={YOUTUBE_CHANNEL_ID}"
    r = requests.get(url, timeout=10)
    r.raise_for_status()

    root = ET.fromstring(r.text)
    entry = root.find("atom:entry", ATOM_NS)
    if entry is None:
        return None

    video_id = entry.find("yt:videoId", ATOM_NS).text
    title = entry.find("atom:title", ATOM_NS).text
    link = entry.find("atom:link", ATOM_NS).get("href")
    channel_name = get_channel_name(root, entry)

    return {
        "id": video_id,
        "title": title,
        "url": link,
        "channel_name": channel_name,
    }


# =========================
# AUTOCHECK – NIE DOPPELT ANKÜNDIGEN
# =========================

@tasks.loop(seconds=CHECK_INTERVAL_SECONDS)
async def check_youtube():
    """
    Prüft regelmäßig, ob ein neues Video im Feed ist.
    Wenn ja → @everyone + Text + Link (kein Embed).
    Das gleiche Video wird nie zweimal angekündigt (IDs werden in Datei + Cache gespeichert).
    """
    global announced_ids_cache

    try:
        # Cache einmalig aus Datei laden
        if not announced_ids_cache:
            announced_ids_cache = load_announced_video_ids()
            print(f"✅ Geladene angekündigte IDs: {announced_ids_cache}")

        latest = fetch_latest_video()

        if latest is None:
            print("ℹ️ Kein Video im Feed gefunden.")
            return

        vid_id = latest["id"]

        # Wenn dieses Video schonmal angekündigt wurde → überspringen
        if vid_id in announced_ids_cache:
            print(f"ℹ️ Kein neues Video (bereits angekündigt: {vid_id}).")
            return

        # Neues Video → ankündigen
        channel = bot.get_channel(YOUTUBE_ANNOUNCE_CHANNEL_ID)
        if channel is None:
            print("❌ YouTube-Ankündigungs-Channel nicht gefunden!")
            return

        msg = (
            "@everyone 📢 **Neues Video auf YouTube!**\n\n"
            f"{latest['url']}"
        )

        await channel.send(msg)

        print(f"📨 Neues Video angekündigt: {latest['title']}")

        # In Datei + Cache eintragen
        save_announced_video_id(vid_id)
        announced_ids_cache.add(vid_id)

    except Exception as e:
        print("❌ Fehler im YouTube-Check:", e)


@check_youtube.before_loop
async def before_check_youtube_loop():
    await bot.wait_until_ready()

GUILD_ID = 1438214282180296867 
WELCOME_CHANNEL_ID = 1438214283333861501 # Channel für Willkommensnachricht

def create_welcome_embed(member):
    embed = discord.Embed(
        title="👋 Herzlich Willkommen auf dem Server von AetherionCraft!",
        description=(
            f"Willkommen <@{member.id}>! Bitte lese dir die Regeln durch und Akzeptiere sie Anschließend.\n\n"
            f"**Wir freuen uns, dass du da bist!**\n"
            f"Wir haben jetzt **{member.guild.member_count} Mitglieder** auf dem Server."
        ),
        color=discord.Color.from_str("#0011FF")
    )

    embed.set_thumbnail(url=member.display_avatar.url)
    embed.set_image(url="")  # <-- Ersetze mit deinem GIF/Link
    embed.set_footer(text="Viel Spaß bei uns!", icon_url="")
    

    return embed

# === Event: Neues Mitglied (inkl. Bots) ===
@bot.event
async def on_member_join(member):
    print(f"📥 {member} ist dem Server beigetreten.")
    channel = bot.get_channel(WELCOME_CHANNEL_ID)
    if channel is None:
        print("❌ Willkommenskanal nicht gefunden.")
        return

    embed = create_welcome_embed(member)
    await channel.send(embed=embed)
    print("✅ Willkommensnachricht gesendet.")

SUPPORT_VOICE_CHANNEL_ID = 1446141745640505374  # Warteraum Voice Channel ID
SUPPORT_KATEGORIE_ID = 1445171441485222031      # Kategorie für Support-Channels
ADMIN_CHANNEL_ID = 1446142013563998220          # Admin Textchannel ID
ADMIN_ROLE_ID = 1445171945942417408             # Admin Rolle ID

support_requests = {}  # user_id: waiting (Warteraum-ID)
support_channels = []  # aktive Supportchannel-IDs


def generate_channel_name(guild: discord.Guild):
    count = 1
    existing_names = [ch.name for ch in guild.voice_channels]
    while True:
        name = f"┣│🔊│Bearbeitung Support {count}"
        if name not in existing_names:
            return name
        count += 1


class RejectReasonModal(discord.ui.Modal, title="Support-Anfrage ablehnen"):
    def __init__(self, member: discord.Member, view: View):
        super().__init__()
        self.member = member
        self.view = view

    reason = discord.ui.TextInput(
        label="Ablehnungsgrund",
        style=discord.TextStyle.paragraph,
        placeholder="Bitte gib einen nachvollziehbaren Grund an...",
        required=True,
        max_length=300
    )

    async def on_submit(self, interaction: discord.Interaction):
        # User aus Voice-Channel kicken
        try:
            await self.member.move_to(None)
        except:
            pass

        # DM mit Grund senden
        try:
            embed = discord.Embed(
                title="❌ Deine Support-Anfrage wurde abgelehnt",
                description=f"**Grund:** {self.reason.value}",
                color=discord.Color.red()
            )
            await self.member.send(embed=embed)
        except:
            await interaction.followup.send("Konnte dem Benutzer keine DM senden.", ephemeral=True)

        # Buttons deaktivieren
        for child in self.view.children:
            if isinstance(child, discord.ui.Button):
                child.disabled = True

        await interaction.message.edit(view=self.view)
        await interaction.response.send_message("Benutzer wurde abgelehnt und informiert.", ephemeral=True)

        # Anfrage löschen
        support_requests.pop(self.member.id, None)


class AcceptSupportView(View):
    def __init__(self, member: discord.Member):
        super().__init__(timeout=None)
        self.member = member

    @discord.ui.button(label="Annehmen", style=discord.ButtonStyle.green, custom_id="accept_support")
    async def accept_callback(self, interaction: discord.Interaction, button: discord.ui.Button):
        if not interaction.user.guild_permissions.administrator:
            await interaction.response.send_message("Nur Admins können diesen Button nutzen.", ephemeral=True)
            return

        guild = interaction.guild
        category = discord.utils.get(guild.categories, id=SUPPORT_KATEGORIE_ID)
        name = generate_channel_name(guild)

        overwrites = {
            guild.default_role: discord.PermissionOverwrite(connect=False),
            self.member: discord.PermissionOverwrite(connect=True),
            interaction.user: discord.PermissionOverwrite(connect=True)
        }

        support_channel = await guild.create_voice_channel(name, overwrites=overwrites, category=category)
        support_channels.append(support_channel.id)

        # User verschieben
        try:
            await self.member.move_to(support_channel)
        except:
            pass

        # Admin verschieben
        if interaction.user.voice and interaction.user.voice.channel:
            try:
                await interaction.user.move_to(support_channel)
                moved_admin = True
            except:
                moved_admin = False
        else:
            moved_admin = False

        # Buttons deaktivieren
        for child in self.children:
            if isinstance(child, discord.ui.Button):
                child.disabled = True

        await interaction.response.edit_message(view=self)

        # Rückmeldung
        if moved_admin:
            msg = f"Support-Channel **{name}** wurde erstellt. {self.member.display_name} und du wurden verschoben."
        else:
            msg = (
                f"Support-Channel **{name}** wurde erstellt und {self.member.display_name} wurde verschoben.\n"
                f"⚠️ Du wurdest nicht verschoben, da du dich in keinem Voice-Channel befindest."
            )

        await interaction.followup.send(msg, ephemeral=True)
        support_requests.pop(self.member.id, None)

    @discord.ui.button(label="Ablehnen", style=discord.ButtonStyle.danger, custom_id="reject_support")
    async def reject_callback(self, interaction: discord.Interaction, button: discord.ui.Button):
        if not interaction.user.guild_permissions.administrator:
            await interaction.response.send_message("Nur Admins können diesen Button nutzen.", ephemeral=True)
            return

        modal = RejectReasonModal(self.member, self)
        await interaction.response.send_modal(modal)


@bot.event
async def on_voice_state_update(member, before, after):
    # Wenn User den Warteraum betritt
    if after.channel and after.channel.id == SUPPORT_VOICE_CHANNEL_ID and (before.channel != after.channel):
        now = datetime.now(ZoneInfo("Europe/Berlin"))

        embed = discord.Embed(
            title="Support-Anfrage",
            description="Ein User wartet im Support-Warteraum.",
            color=discord.Color.from_str("#0011FF")
        )
        embed.add_field(name="Nickname", value=member.display_name, inline=True)
        embed.add_field(name="Username", value=str(member), inline=True)
        embed.add_field(name="Datum", value=now.strftime("%d.%m.%Y"), inline=True)
        embed.add_field(name="Uhrzeit", value=now.strftime("%H:%M:%S"), inline=True)
        embed.set_thumbnail(url=member.avatar.url if member.avatar else member.default_avatar.url)

        admin_channel = bot.get_channel(ADMIN_CHANNEL_ID)
        if admin_channel:
            view = AcceptSupportView(member)
            await admin_channel.send(
                content=f"<@&{ADMIN_ROLE_ID}> Ein Benutzer wartet auf Support.",
                embed=embed,
                view=view
            )

        support_requests[member.id] = after.channel.id

    # User verlässt Warteraum → Anfrage entfernen
    if before.channel and before.channel.id == SUPPORT_VOICE_CHANNEL_ID and member.id in support_requests:
        support_requests.pop(member.id)

    # Leerer Support-Channel → löschen
    if before.channel and before.channel.id in support_channels:
        if len(before.channel.members) == 0:
            await before.channel.delete()
            support_channels.remove(before.channel.id)

# --- Bot starten---
bot.run("MTQ0NTE2NTUxMTQ5ODI2ODY5Mg.Gwt0xF.e-XtPJSTzgXEmcV71mHWsj-MI601gGS7Xy-sho")