#Polyák Levente 13/C
from machine import Pin
from time import sleep_ms, localtime
from tm1638 import TM1638
import esp32
kij = TM1638(Pin(0), Pin(1), Pin(2), 2)
gombok = [Pin(i, Pin.IN, Pin.PULL_UP) for i in range(3, 7)]

adathalmaz = [
    {"név": "vent", "mód": True, "tip": 'b', "ah": None, "fh": None, "érték": False},
    {"név": "vent", "mód": True, "tip": 'i', "ah": 1, "fh": 5, "érték": 2},
    {"név": "fut", "mód": True, "tip": 'b', "ah": None, "fh": None, "érték": True},
    {"név": "fut", "mód": True, "tip": 'i', "ah": 20, "fh": 100, "érték": 35},
    {"név": "hom", "mód": False, "tip": 's', "ah": None, "fh": None, "érték": "--"},
    {"név": "ido", "mód": False, "tip": 's', "ah": None, "fh": None, "érték": "--"}
]

menu_index = 0
def frissit_kijelzo():
    """Frissíti a kijelző tartalmát a kiválasztott elem alapján"""
    elem = adathalmaz[menu_index]

    if elem['név'] == "hom":
        # Hőmérséklet kiolvasása az ESP32-ből
        elem['érték'] = f"{esp32.mcu_temperature():.1f}C"
    elif elem['név'] == "ido":
        # Idő lekérdezése
        now = localtime()
        elem['érték'] = f"{now[3]:02}.{now[4]:02}"

    kij.clear()
    nev = elem['név'][:4]
    ertek = str(elem['érték'])[:5]
    kij.show(f"{nev:<4}{ertek:>4}")

def kovetkezo_menu():
    """Menüpont váltás előrefele"""
    global menu_index
    menu_index = (menu_index + 1) % len(adathalmaz)
    frissit_kijelzo()

def elozo_menu():
    """Menüpont váltás hátrafele"""
    global menu_index
    menu_index = (menu_index - 1) % len(adathalmaz)
    frissit_kijelzo()

def ertek_novel():
    """Érték növelése"""
    elem = adathalmaz[menu_index]
    if elem['mód'] and elem['tip'] == 'i' and elem['érték'] < elem['fh']:
        elem['érték'] += 1
        frissit_kijelzo()

def ertek_csokkent():
    """Érték csökkentése"""
    elem = adathalmaz[menu_index]
    if elem['mód'] and elem['tip'] == 'i' and elem['érték'] > elem['ah']:
        elem['érték'] -= 1
        frissit_kijelzo()

def boolean_valtas():
    """Logikai érték váltás"""
    elem = adathalmaz[menu_index]
    if elem['mód'] and elem['tip'] == 'b':
        elem['érték'] = not elem['érték']
        frissit_kijelzo()

def gombok_ellenorzes():
    """Gombok állapotának ellenőrzése és megfelelő akciók végrehajtása"""
    pressed = kij.keys()
    sleep_ms(250)

    if pressed & 1 > 0:
        kovetkezo_menu()

    if pressed & 4 > 0:
        if adathalmaz[menu_index]['tip'] == 'i':
            ertek_novel()
        elif adathalmaz[menu_index]['tip'] == 'b':
            boolean_valtas()

    if pressed & 8 > 0:
        if adathalmaz[menu_index]['tip'] == 'i':
            ertek_csokkent()

frissit_kijelzo()

while True:
    gombok_ellenorzes()

    if adathalmaz[menu_index]['név'] in ["hom", "ido"]:
        frissit_kijelzo()
    sleep_ms(10)

                    
                

                    
import sqlite3
import os
from time import *

FILE_NAME = "autok.txt"
DB_NAME = "autok.db"
BR = "\n"*10

def init_db():
    conn = sqlite3.connect(DB_NAME)
    cursor = conn.cursor()
    cursor.execute("""
    CREATE TABLE IF NOT EXISTS autok (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        rendszam TEXT NOT NULL,
        tipus TEXT NOT NULL,
        szin TEXT NOT NULL,
        evjarat INTEGER NOT NULL,
        allapot TEXT NOT NULL
    )
    """)
    conn.commit()
    conn.close()

def tovabb():
    input("Nyomjon ENTERT a folytatáshoz...")
    print(BR)

def add_auto(rendszam, tipus, szin, evjarat, allapot):
    conn = sqlite3.connect(DB_NAME)
    cursor = conn.cursor()
    cursor.execute("INSERT INTO autok (rendszam, tipus, szin, evjarat, allapot) VALUES (?, ?, ?, ?, ?)",
                    (rendszam, tipus, szin, evjarat, allapot))
    conn.commit()
    conn.close()
    print("Autó sikeresen hozzáadva!")
    tovabb()

def list_autok():
    conn = sqlite3.connect(DB_NAME)
    cursor = conn.cursor()
    cursor.execute("SELECT * FROM autok")
    autok = cursor.fetchall()
    conn.close()
    if autok:
        for auto in autok:
            print(f"ID: {auto[0]}, Rendszám: {auto[1]}, Típus: {auto[2]}, Szín: {auto[3]}, Évjárat: {auto[4]}, Állapot: {auto[5]}")
        tovabb()
    else:
        print("Nincs még rögzített autó.")
        tovabb()

def delete_auto(auto_id):
    conn = sqlite3.connect(DB_NAME)
    cursor = conn.cursor()
    cursor.execute("DELETE FROM autok WHERE id = ?", (auto_id,))
    conn.commit()
    conn.close()
    print("Autó sikeresen törölve!")
    tovabb()

def save_to_file():
    conn = sqlite3.connect(DB_NAME)
    cursor = conn.cursor()
    cursor.execute("SELECT * FROM autok")
    autok = cursor.fetchall()
    conn.close()
    with open(FILE_NAME, "w") as file:
        for auto in autok:
            file.write(f"{auto[1]},{auto[2]},{auto[3]},{auto[4]},{auto[5]}\n")
    print("Adatok sikeresen mentve a fájlba!")
    tovabb()

def load_from_file():
    if os.path.exists(FILE_NAME):
        with open(FILE_NAME, "r") as file:
            for line in file:
                rendszam, tipus, szin, evjarat, allapot = line.strip().split(",")
                add_auto(rendszam, tipus, szin, int(evjarat), allapot)
        print("Adatok sikeresen betöltve a fájlból!")
#        tovabb()
    else:
        print("Nincs mentett fájl az adatokhoz.")
        tovabb()

def drop_table():
    print(f"{BR}Tábla törlése.");sleep(0.2);print("Tábla törlése..");sleep(0.2);print("Tábla törlése...");sleep(0.2)
    conn = sqlite3.connect(DB_NAME)
    cursor = conn.cursor()
    cursor.execute(f"DROP TABLE \"{DB_NAME[:-3]}\" ");print("Tábla törölve!")
    conn.commit()
    conn.close()
    tovabb()

def menu():
    while True:
        print("--- Autóflotta Kezelés ---\n1. Új autó hozzáadása\n2. Autók listázása\n3. Autó törlése\n4. Adatok mentése fájlba\n5. Adatok betöltése fájlból\n6. DROP TABLE\n7. Kilépés")
        choice = input("Válassz egy lehetőséget: ")

        if choice == "1":
            rendszam = input("Rendszám: ")
            tipus = input("Típus: ")
            szin = input("Szín: ")
            try:
                evjarat = int(input("Évjárat: "))
                bad=False
            except:
                bad=True
            allapot = input("Állapot: ")
            if bad == False:
                add_auto(rendszam, tipus, szin, evjarat, allapot)
            else:
                print("Hiba történt a beolvasás közben.")
                tovabb()
        elif choice == "2":
            list_autok()
        elif choice == "3":
            auto_id = int(input("Add meg az autó ID-ját, amit törölni szeretnél: "))
            delete_auto(auto_id)
        elif choice == "4":
            save_to_file()
        elif choice == "5":
            load_from_file()
        elif choice == "6":
            v = input("Biztosan törölni szeretnéd? (IGEN/NEM): ")
            if v=="IGEN":
                drop_table()
                init_db()
            else:
                print("Mégse.")
                tovabb()
        elif choice == "7":
            print("Kilépés...")
            break
        else:
            print("Érvénytelen választás, próbáld újra!")
            tovabb()

if __name__ == "__main__":
    init_db()
    menu()


                    
                

                    
from logging import exception
import discord
from discord.ext import commands, tasks
from discord import app_commands
import requests
from color_converter import get_color_value
import subprocess
from datetime import datetime
import time
import sqlite3
import asyncio

bot_start_time=datetime.now()

conn = sqlite3.connect('terulet.db')
c = conn.cursor()
c.execute('''CREATE TABLE IF NOT EXISTS terulet (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                nev TEXT,
                hely TEXT,
                tulajdonos TEXT,
                tamadhato TEXT,
                message_id INTEGER
            )''')
conn.commit()

conn_transactions = sqlite3.connect('transactions.db')
c_transactions = conn.cursor()
c_transactions.execute('''CREATE TABLE IF NOT EXISTS transactions (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                user_id TEXT,
                user_name TEXT,
                action TEXT,
                item TEXT,
                timestamp TEXT
            )''')
conn.commit()


print("\n "*40)
intents = discord.Intents.default()
intents.messages = True

class MyBot(commands.Bot):
    async def setup_hook(self):
        self.loop.create_task(run_task_every_minute())

bot = MyBot(command_prefix="!", intents=intents)

ADATBAZISKEZELO_BT = "Webhook url"
LOPASGATLO_BT = "Webhook url"
LEADER_TAROLO = "Webhook url"
ALLOWED_CHANNEL_ID = 123456789
TERULETEK_CHANNEL_ID = 123456789
TOKEN="A Bot tokenje."


def c_time():
    return datetime.now().strftime("%H:%M:%S")

async def notify_owner(interaction: discord.Interaction):
    try:
        owner = await bot.fetch_user(266275494700384256)
        command_name = interaction.command.name
        user = interaction.user
        run_time = c_time()
        message = f"**Command:** {command_name}\n**User:** {user}\n**Time:** {run_time}"
        allowed_mentions = discord.AllowedMentions(users=False, roles=False, everyone=False)
        sent_message = await owner.send(content=message, allowed_mentions=allowed_mentions, silent=True)
        await sent_message.edit(suppress=True)
        return True
    except Exception as e:
        print(f"Failed to notify owner: {e}")
        return False

def notify_owner_sync(interaction: discord.Interaction):
    return asyncio.ensure_future(notify_owner(interaction))


@bot.event
async def on_ready():
    try:
        synced_name = ""
        synced = await bot.tree.sync()
        
        print(f"Bot {bot.user} elindult! Syncelt parancsok: {len(synced)}")
        print("Invite link: https://discord.com/oauth2/authorize?client_id=805024189269934080&scope=bot&permissions=414531963968")
        for x in synced:
            synced_name = synced_name + x.name + ", "
        
        print(f"Sikeresen szinkronizálva: {synced_name}")
        run_task_every_minute.start()

        user = await bot.fetch_user(266275494700384256)
        await user.send(f"Bot {bot.user} elindult! Syncelt parancsok: {len(synced)}")
    except Exception as e:
        print(f"Hiba történt a parancsok szinkronizálásakor: {e}")

########################################################################################################################
#                                     C O M M A N D S   S T A R T   H E R E                                            #
########################################################################################################################

@bot.tree.command(name="uptime", description="Bot uptime.")
@app_commands.check(notify_owner)
async def uptime(interaction: discord.Interaction):
    uptime_duration = datetime.now() - bot_start_time
    days, seconds = uptime_duration.days, uptime_duration.seconds
    hours = seconds // 3600
    minutes = (seconds % 3600) // 60
    seconds = seconds % 60
    formatted_uptime = f"{days}d {hours}h {minutes}m {seconds}s"
    embed = discord.Embed(title="Bot Uptime", description=f"**{formatted_uptime}**", color=discord.Color.blue())
    await interaction.response.send_message(embed=embed, ephemeral=True)

@bot.tree.command(name="sort_sheet", description="Lefuttatja a Google Sheets scriptet.")
@app_commands.check(notify_owner_sync)
async def sort_sheet(interaction: discord.Interaction):
    await interaction.response.defer(ephemeral=True)

    url = "https://script.google.com/macros/s/AKfycbwAvo5MP_KcpeXb4nGxgWhyQOMoOhzIHF8L6lKVXkqR5xuUupsIwmpswfIxWTeVUYhN9w/exec"
    
    try:
        response = requests.post(url, data={"action": "sort"})

        if response.status_code == 200:
            message = "Google Sheets script sikeresen lefuttatva!"
        else:
            message = f"Sikertelenül futott le ez: {response.text}"

    except Exception as e:
        message = f"Váratlan hiba történt, hibaüzenet: {e}"

    await interaction.followup.send(message, ephemeral=True)  # Későbbi válaszküldés



@bot.tree.command(name="terulet_add", description="Új terület hozzáadása.")
@app_commands.check(notify_owner)
@app_commands.describe(nev="Add meg a terület nevét", hely="Add meg a terület helyét", tulajdonos="Add meg kié a terület", tamadhato="Add meg mikor támadható a terület")
async def terulet_add(interaction: discord.Interaction, nev: str, hely: str, tulajdonos: str, tamadhato: str):
    if interaction.channel_id != TERULETEK_CHANNEL_ID:
        await interaction.response.send_message("Ezt a parancsot csak a megfelelő csatornán lehet használni.", ephemeral=True)
        return
    else:
        c.execute("INSERT INTO terulet (nev, hely, tulajdonos, tamadhato) VALUES (?, ?, ?, ?)", (nev, hely, tulajdonos, tamadhato))
        conn.commit()
        record_id = c.lastrowid

        embed = discord.Embed(title=nev, color=0x00ff00)
        embed.add_field(name="Hely", value=hely, inline=True)
        embed.add_field(name="Tulajdonos", value=tulajdonos, inline=True)
        embed.add_field(name="Támadható", value=tamadhato, inline=True)
        embed.set_footer(text=f"ID: {record_id}")

        message = await interaction.channel.send(embed=embed)
        c.execute("UPDATE terulet SET message_id = ? WHERE id = ?", (message.id, record_id))
        conn.commit()

        await interaction.response.send_message("Terület hozzáadva!", ephemeral=True)



@bot.tree.command(name="terulet_edit", description="Egy meglévő terület szerkesztése.")
@app_commands.check(notify_owner)
@app_commands.describe(id="A szerkesztendő terület ID-ja", nev="Add meg a terület nevét", hely="Add meg a terület helyét", tulajdonos="Add meg kié a terület", tamadhato="Add meg mikor támadható a terület", color="Add meg az embed színét")
async def terulet_edit(interaction: discord.Interaction, id: int, nev: str = None, hely: str = None, tulajdonos: str = None, tamadhato: str = None, color:str = None):
    if interaction.channel_id != TERULETEK_CHANNEL_ID:
        await interaction.response.send_message("Ezt a parancsot csak a megfelelő csatornán lehet használni.", ephemeral=True)
        return
    else:
        try:
            color_value = get_color_value(color)
            if color_value is None:
                await interaction.response.send_message("Ismeretlen szín.", ephemeral=True)
                return
        except Exception as e:
            await interaction.response.send_message(f"Hiba {e}", ephemeral=True)
        c.execute("SELECT * FROM terulet WHERE id = ?", (id,))
        record = c.fetchone()
        if not record:
            await interaction.response.send_message("Hiba: Érvénytelen ID!", ephemeral=True)
            return

        if nev:
            c.execute("UPDATE terulet SET nev = ? WHERE id = ?", (nev, id))
        if hely:
            c.execute("UPDATE terulet SET hely = ? WHERE id = ?", (hely, id))
        if tulajdonos:
            c.execute("UPDATE terulet SET tulajdonos = ? WHERE id = ?", (tulajdonos, id))
        if tamadhato:
            c.execute("UPDATE terulet SET tamadhato = ? WHERE id = ?", (tamadhato, id))
        conn.commit()

        c.execute("SELECT * FROM terulet WHERE id = ?", (id,))
        record = c.fetchone()
        embed = discord.Embed(title=record[1], color=color_value)
        embed.add_field(name="Hely", value=record[2], inline=True)
        embed.add_field(name="Tulajdonos", value=record[3], inline=True)
        embed.add_field(name="Támadható", value=record[4], inline=True)
        embed.set_footer(text=f"ID: {id}")

        message_id = record[5]
        channel = interaction.channel
        message = await channel.fetch_message(message_id)
        await message.edit(embed=embed)

        await interaction.response.send_message("Terület módosítva!", ephemeral=True)



@bot.tree.command(name="terulet_delete", description="Egy terület törlése az ID alapján.")
@app_commands.check(notify_owner)
@app_commands.describe(id="A törlendő terület ID-ja")
async def terulet_delete(interaction: discord.Interaction, id: int):
    if interaction.channel_id != TERULETEK_CHANNEL_ID:
        await interaction.response.send_message("Ezt a parancsot csak a megfelelő csatornán lehet használni.", ephemeral=True)
        return
    else:
        c.execute("SELECT message_id FROM terulet WHERE id = ?", (id,))
        record = c.fetchone()
        if not record:
            await interaction.response.send_message("Hiba: Érvénytelen ID!", ephemeral=True)
            return

        message_id = record[0]
        channel = interaction.channel
        message = await channel.fetch_message(message_id)
        await message.delete()

        c.execute("DELETE FROM terulet WHERE id = ?", (id,))
        conn.commit()

        await interaction.response.send_message("Terület törölve!", ephemeral=True)



@bot.tree.command(name="adataim", description="Adatrögzítés az 'adataim' csatornába")
@app_commands.check(notify_owner)
@app_commands.describe(nev="Add meg a neved", telefonszam="Add meg a telefonszámod", emlites="Opcionális említés")
async def adataim(interaction: discord.Interaction, nev: str, telefonszam: str, emlites: str = None):
    print(f"adataim has run at {c_time()}.")
    try:
        user_mention = interaction.user.mention
        mention_to_send = emlites if emlites else user_mention
        user_id = int(mention_to_send.strip('<@!>'))
        mentioned_user = await bot.fetch_user(user_id)
        embed = {
            "embeds": [
                {
                    "title": nev,
                    "fields": [
                        {"name": "Telefonszám", "value": telefonszam, "inline": True},
                        {"name": "Discord", "value": mention_to_send, "inline": True},
                    ],
                    "thumbnail": {
                        "url": mentioned_user.avatar.url
                    }
                }
            ]
        }
        response = requests.post(ADATBAZISKEZELO_BT, json=embed)
        if response.status_code == 204:
            await interaction.response.send_message("Az adatok sikeresen elküldve a webhooknak!", ephemeral=True)
        else:
            await interaction.response.send_message(
                f"Hiba történt az adatok küldése közben: {response.status_code}",
                ephemeral=True,
            )
    except Exception as e:
        await interaction.response.send_message(f"Hiba történt: {e}", ephemeral=True)



@bot.tree.command(name="ki", description="Fegyver kivétel logolása.")
@app_commands.check(notify_owner)
@app_commands.describe(fegyverki="Milyen fegyvert vettél ki?", emlites="Ki vette ki? (Alapértelmezés: Te)")
async def ki(interaction: discord.Interaction, fegyverki: str, emlites: str = None):
    print(f"ki has run at {c_time()}.")
    try:
        user_mention = interaction.user.mention
        mention_to_send = emlites if emlites else user_mention

        user_id = int(mention_to_send.strip('<@!>'))
        mentioned_user = await bot.fetch_user(user_id)

        embed = discord.Embed(title="Kivétel", color=14553102)
        embed.add_field(name="Discord", value=mention_to_send, inline=True)
        embed.add_field(name="Item", value=fegyverki, inline=True)
        embed.set_thumbnail(url=mentioned_user.avatar.url)

        response = requests.post(LOPASGATLO_BT, json={"embeds": [embed.to_dict()]})

        if response.status_code == 204:
            await interaction.response.send_message("Az adatok sikeresen elküldve a webhooknak!", ephemeral=True)
            # Save to database
            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            c_transactions.execute("INSERT INTO transactions (user_id, user_name, action, item, timestamp) VALUES (?, ?, ?, ?, ?)",(user_id, mention_to_send, 'ki', fegyverki, timestamp))
            conn_transactions.commit()
        else:
            await interaction.response.send_message(f"Hiba történt az adatok küldése közben: {response.status_code}", ephemeral=True)
        
    except ValueError:
        await interaction.response.send_message("Hiba: Érvénytelen említés formátum! Használj egy @említést.", ephemeral=True)
    except Exception as e:
        await interaction.response.send_message(f"Hiba történt: {e}", ephemeral=True)

@bot.tree.command(name="be", description="Fegyver betétel logolása.")
@app_commands.check(notify_owner)
@app_commands.describe(fegyverbe="Milyen fegyvert tettél be?", emlites="Ki tette be? (Alapértelmezés: Te)")
async def be(interaction: discord.Interaction, fegyverbe: str, emlites: str = None):
    print(f"be has run at {c_time()}.")
    try:
        user_mention = interaction.user.mention
        mention_to_send = emlites if emlites else user_mention
        user_id = int(mention_to_send.strip('<@!>'))
        mentioned_user = await bot.fetch_user(user_id)
    
        embed = discord.Embed(title="Betett", color=974094)
        embed.add_field(name="Discord", value=mention_to_send)
        embed.add_field(name="Item", value=fegyverbe)
        embed.set_thumbnail(url=mentioned_user.avatar.url)

        response = requests.post(LOPASGATLO_BT, json={"embeds": [embed.to_dict()]})

        if response.status_code == 204:
            await interaction.response.send_message("Az adatok sikeresen elküldve a webhooknak!", ephemeral=True)
            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            c_transactions.execute("INSERT INTO transactions (user_id, user_name, action, item, timestamp) VALUES (?, ?, ?, ?, ?)",(user_id, mention_to_send, 'be', fegyverbe, timestamp))
            conn_transactions.commit()
        else:
            await interaction.response.send_message(f"Hiba történt az adatok küldése közben: {response.status_code}", ephemeral=True)
    except ValueError:
        await interaction.response.send_message("Hiba: Érvénytelen említés formátum! Használj egy @említést.", ephemeral=True)
    except Exception as e:
        await interaction.response.send_message(f"Hiba történt: {e}", ephemeral=True)

@bot.tree.command(name="lekérdezés", description="Lekérdezi egy személy tranzakcióit.")
@app_commands.check(notify_owner)
@app_commands.describe(user="A személy, akinek a tranzakcióit le akarod kérdezni", ev="Év (opcionális)", ho="Hónap (opcionális)", nap="Nap (opcionális)")
async def lekerdezes(interaction: discord.Interaction, user: discord.User, ev: int = None, ho: int = None, nap: int = None):
    print(f"lekérdezés has run at {c_time()}.")
    try:
        query = "SELECT action, item, timestamp FROM transactions WHERE user_id = ?"
        params = [str(user.id)]

        if ev:
            query += " AND strftime('%Y', timestamp) = ?"
            params.append(str(ev))
        if ho:
            query += " AND strftime('%m', timestamp) = ?"
            params.append(f"{ho:02d}")
        if nap:
            query += " AND strftime('%d', timestamp) = ?"
            params.append(f"{nap:02d}")

        c_transactions.execute(query, params)
        transactions = c_transactions.fetchall()

        if transactions:
            embed = discord.Embed(title=f"{user.name} tranzakciói", color=discord.Color.blue())
            for action, item, timestamp in transactions:
                embed.add_field(name=f"{action.capitalize()} - {timestamp}", value=item, inline=False)
            await interaction.response.send_message(embed=embed, ephemeral=True)
        else:
            await interaction.response.send_message("Nincsenek tranzakciók a megadott feltételekkel.", ephemeral=True)
    except Exception as e:
        await interaction.response.send_message(f"Hiba történt: {e}", ephemeral=True)

@bot.tree.command(name="leader_ki", description="Leader fegyver kivétel logolása.")
@app_commands.check(notify_owner)
@app_commands.describe(ember="Kinek vetted ki?",fegyverki="Milyen fegyvert vettél ki?")
async def leader_ki(interaction: discord.Interaction, fegyverki: str, ember:str):
    print(f"leader_ki has run at {c_time()}.")
    if interaction.channel_id != ALLOWED_CHANNEL_ID:
        await interaction.response.send_message("Ezt a parancsot csak egy meghatározott csatornán lehet használni.", ephemeral=True)
        return
    try:
        user_mention = interaction.user.mention
        avatar = interaction.user.avatar.url

        embed = discord.Embed(title="Kivétel", color=14553102)
        embed.add_field(name="Kinek", value=ember)
        embed.add_field(name="Item", value=fegyverki)
        embed.add_field(name="Könyvelő", value=interaction.user.mention)
        embed.set_thumbnail(url=avatar)

        response = requests.post(LEADER_TAROLO, json={"embeds": [embed.to_dict()]})

        if response.status_code == 204:
            await interaction.response.send_message("Az adatok sikeresen elküldve a webhooknak!", ephemeral=True)
        else:
            await interaction.response.send_message(f"Hiba történt az adatok küldése közben: {response.status_code}", ephemeral=True)
    except ValueError:
        await interaction.response.send_message("Hiba: Érvénytelen említés formátum! Használj egy @említést.", ephemeral=True)
    except Exception as e:
        await interaction.response.send_message(f"Hiba történt: {e}", ephemeral=True)



@bot.tree.command(name="leader_be", description="Leader fegyver betétel logolása.")
@app_commands.check(notify_owner)
@app_commands.describe( ember="Kinek tette be?", fegyverbe="Milyen fegyvert tettél be?")
async def leader_be(interaction: discord.Interaction, fegyverbe: str, ember:str):
    print(f"leader_be has run at {c_time()}.")
    if interaction.channel_id != ALLOWED_CHANNEL_ID:
        await interaction.response.send_message("Ezt a parancsot csak egy meghatározott csatornán lehet használni.", ephemeral=True)
        return
    try:
        user_mention = interaction.user.mention
        avatar = interaction.user.avatar.url
        embed = discord.Embed(title="Betett", color=974094)
        embed.add_field(name="Kinek", value=ember)
        embed.add_field(name="Item", value=fegyverbe)
        embed.add_field(name="Könyvelő", value=interaction.user.mention)
        embed.set_thumbnail(url=avatar)

        response = requests.post(LEADER_TAROLO, json={"embeds": [embed.to_dict()]})

        if response.status_code == 204:
            await interaction.response.send_message("Az adatok sikeresen elküldve a webhooknak!", ephemeral=True)
        else:
            await interaction.response.send_message(f"Hiba történt az adatok küldése közben: {response.status_code}", ephemeral=True)
    except ValueError:
        await interaction.response.send_message("Hiba: Érvénytelen említés formátum! Használj egy @említést.", ephemeral=True)
    except Exception as e:
        await interaction.response.send_message(f"Hiba történt: {e}", ephemeral=True)



@bot.tree.command(name="embed", description="Írj egy egyedi beágyazott üzenetet!")
@app_commands.check(notify_owner)
@app_commands.describe(title="Az üzenet címe", description="Az üzenet tartalma", color="Az üzenet színe")
async def embed(interaction: discord.Interaction, title: str, description: str, color: str):
    print(f"embed has run at {c_time()}.")
    color_value = get_color_value(color)
    if color_value is None:
        await interaction.response.send_message("Ismeretlen szín.", ephemeral=True)
        return
    if len(title) >= 256:
        await interaction.response.send_message("Nem vicces.", ephemeral=True)
        return
    if len(description) >= 4096:
        await interaction.response.send_message("Még mindig nem vicces.", ephemeral=True)
        return

    embed = discord.Embed(title=title, description=description, color=color_value)
    try:
        await interaction.response.send_message(embed=embed)
    except Exception as e:
        await interaction.response.send_message(f"Váratlan hiba történt, hibaüzenet: {e}", ephemeral=True)



@bot.tree.command(name="move_all", description="Összes felhasználó áthelyezése egyik hangcsatornából a másikba.")
@app_commands.check(notify_owner)
@app_commands.describe(from_channel="A csatorna ID-je amelyik csatornából szeretnéd áthelyezni", to_channel="A csatorna ID-je amelyik csatornába szeretnéd áthelyezni", except_users="Felhasználók ID-je vesszővel elválasztva, akiket nem szeretnél áthelyezni")
async def move_all(interaction: discord.Interaction, from_channel: str, to_channel: str, except_users: str = ""):
    print(f"move_all has run at {c_time()}.")
    try:
        from_channel_id = int(from_channel)
        to_channel_id = int(to_channel)
        except_user_ids = [int(user_id.strip()) for user_id in except_users.split(",") if user_id.strip()]

        from_channel_obj = bot.get_channel(from_channel_id)
        to_channel_obj = bot.get_channel(to_channel_id)

        if not from_channel_obj or not to_channel_obj:
            await interaction.response.send_message("Érvénytelen felhasználói azonosítókat adtál meg.", ephemeral=True)
            return

        moved_users = []
        for member in from_channel_obj.members:
            if member.id not in except_user_ids:
                await member.move_to(to_channel_obj)
                moved_users.append(member.name)

        await interaction.response.send_message(f"Áthelyezett felhasználók: {', '.join(moved_users)}", ephemeral=True)
    except Exception as e:
        await interaction.response.send_message(f"Váratlan hiba történt, hibaüzenet: {e}", ephemeral=True)



@bot.tree.command(name="server_mute", description="Szerver-szintű némítás.")
@app_commands.check(notify_owner)
@app_commands.describe(user="A felhasználó, akit némítani szeretnél")
async def servermute(interaction: discord.Interaction, user: discord.Member):
    print(f"fogdbe has run at {c_time()}.")
    try:
        await user.edit(mute=True)
        await interaction.response.send_message(f"{user.mention} szerver-szintű némítást kapott.", ephemeral=True)
    except Exception as e:
        await interaction.response.send_message(f"Váratlan hiba történt, hibaüzenet: {e}", ephemeral=True)



@bot.tree.command(name="server_unmute", description="Szerver-szinű némítás feloldása.")
@app_commands.check(notify_owner)
@app_commands.describe(user="A felhasználó, akit feloldani szeretnél")
async def serverunmute(interaction: discord.Interaction, user: discord.Member):
    print(f"fogdki has run at {c_time()}.")
    try:
        await user.edit(mute=False)
        await interaction.response.send_message(f"{user.mention} szerver-szintű némítása feloldva.", ephemeral=True)
    except Exception as e:
        await interaction.response.send_message(f"Váratlan hiba történt, hibaüzenet: {e}", ephemeral=True)



@bot.tree.command(name="disconnect", description="Felhasználó lecsatlakoztatása egy hangcsatornáról.")
@app_commands.check(notify_owner)
@app_commands.describe(user="A felhasználó, akit le szeretnél csatlakoztatni")
async def disconnect(interaction: discord.Interaction, user: discord.Member):
    print(f"takarodj has run at {c_time()}.")
    try:
        if user.voice:
            await user.move_to(None)
            await interaction.response.send_message(f"{user.mention} lecsatlakoztatva.", ephemeral=True)
        else:
            await interaction.response.send_message(f"{user.mention} jelenleg nincs hangcsatornában.", ephemeral=True)
    except Exception as e:
        await interaction.response.send_message(f"Váratlan hiba történt, hibaüzenet: {e}", ephemeral=True)



@bot.tree.command(name="restart", description="Bot újraindítása.")
@app_commands.check(notify_owner)
@app_commands.describe()
async def restart(interaction: discord.Interaction):
    print(f"restart has run at {c_time()}.")
    if interaction.user.id != 266275494700384256:
        await interaction.response.send_message("Csak a bot tulajdonosa indíthatja újra a botot!", ephemeral=True)
    else:
        await interaction.response.send_message("Tökfej újraindul!...", ephemeral=True)
        await bot.close()
        subprocess.run(["python", "bot.py"])


@bot.tree.command(name="ping", description="Ellenőrizd a bot válaszidejét.")
@app_commands.check(notify_owner)
async def ping(interaction: discord.Interaction):
    print(f"ping has run at {c_time()}.")
    latency = bot.latency * 1000  
    await interaction.response.send_message(f"Bot válaszideje: {latency:.2f} ms", ephemeral=True)



@bot.tree.command(name="spam", description="Küldj el egy egyedi üzenetet többször egy felhasználónak.")
@app_commands.check(notify_owner)
@app_commands.describe(user="A felhasználó akinek szeretnéd küldeni.", message="Az üzenet.", how_many_times="Hányszor szeretnéd elküldeni? (MAX:30)")
async def spam_user(interaction: discord.Interaction, user: discord.User, message: str, how_many_times: str):
    try:
        how_many_times = int(how_many_times)
        if how_many_times > 30:
            await interaction.response.send_message("Csak 30x küldheti el a bot.", ephemeral=True)
            return
        await interaction.response.send_message(f"{how_many_times}x elküldve {user.name}-nak/nek.", ephemeral=True)
        for _ in range(how_many_times):
            time.sleep(0.1)
            await user.send(message)
        
    except Exception as e:
        await interaction.response.send_message(f"Váratlan hiba történt, hibaüzenet: {e}", ephemeral=True)


########################################################################################################################
#                                     C O M M A N D S   E N D   H E R E                                                #
########################################################################################################################


@bot.command()
@commands.is_owner()
async def sync(ctx):
    try:
        synced = await bot.tree.sync()
        await ctx.send(f"Sikeresen szinkronizált {len(synced)} parancsot.")
        await ctx.send(f"Sikeresen szinkronizálva: {synced}")
    except Exception as e:
        await ctx.send(f"Hiba történt a szinkronizálás során: {e}")



@bot.event
async def on_message(message):
    await bot.process_commands(message)
@bot.event
async def on_close():
    conn.close()


@tasks.loop(seconds=60)
async def run_task_every_minute():
    process = await asyncio.create_subprocess_exec(
        "python", "every_minute_and_logging.py",
        stdout=asyncio.subprocess.PIPE,
        stderr=asyncio.subprocess.PIPE
    )
    stdout, stderr = await process.communicate()
    if stdout:
        print(f"[stdout]\n{stdout.decode()}")
    if stderr:
        print(f"[stderr]\n{stderr.decode()}")

bot.run(TOKEN)