import discord
from discord.ext import commands
import aiohttp
import os
import psutil
import platform
import sys
import json
from datetime import datetime
from dotenv import load_dotenv
load_dotenv(override=True)
import openai
import replicate
import io

class General(commands.Cog):
    def __init__(self, bot):
        self.bot = bot
        self.discord_blue = 0x5865F2  # Discord blue barva
        # Deepseek API key
        self.api_key = "sk-8c5fc727862e402b8ca0dcd69eccb96b"
        self.api_base = "https://api.deepseek.com/v1"

    @commands.command(name='tf2')
    async def send_tf2_video(self, ctx):
        """Odešle TF2 video"""
        video_url = "https://www.youtube.com/watch?v=RvVdFXOFcjw"
        await ctx.send(video_url)

    # === ADMIN PŘÍKAZY ===
    
    @commands.command()
    @commands.has_permissions(administrator=True)
    async def load(self, ctx, extension):
        """Načte cog"""
        try:
            await self.bot.load_extension(f'cogs.{extension}')
            embed = discord.Embed(
                title="✅ Cog načten",
                description=f"Modul `{extension}` byl úspěšně načten!",
                color=self.discord_blue
            )
            await ctx.send(embed=embed)
        except Exception as e:
            embed = discord.Embed(
                title="❌ Chyba při načítání",
                description=f"Nepodařilo se načíst `{extension}`:\n```{str(e)[:500]}```",
                color=self.discord_blue
            )
            await ctx.send(embed=embed)

    @commands.command()
    @commands.has_permissions(administrator=True)
    async def unload(self, ctx, extension):
        """Odpojí cog"""
        try:
            await self.bot.unload_extension(f'cogs.{extension}')
            embed = discord.Embed(
                title="✅ Cog odpojen",
                description=f"Modul `{extension}` byl úspěšně odpojen!",
                color=self.discord_blue
            )
            await ctx.send(embed=embed)
        except Exception as e:
            embed = discord.Embed(
                title="❌ Chyba při odpojování",
                description=f"Nepodařilo se odpojit `{extension}`:\n```{str(e)[:500]}```",
                color=self.discord_blue
            )
            await ctx.send(embed=embed)

    @commands.command()
    @commands.has_permissions(administrator=True)
    async def reload(self, ctx, extension):
        """Znovu načte cog"""
        try:
            await self.bot.unload_extension(f'cogs.{extension}')
            await self.bot.load_extension(f'cogs.{extension}')
            embed = discord.Embed(
                title="🔄 Cog znovu načten",
                description=f"Modul `{extension}` byl úspěšně znovu načten!",
                color=self.discord_blue
            )
            await ctx.send(embed=embed)
        except Exception as e:
            embed = discord.Embed(
                title="❌ Chyba při reloadu",
                description=f"Nepodařilo se znovu načíst `{extension}`:\n```{str(e)[:500]}```",
                color=self.discord_blue
            )
            await ctx.send(embed=embed)

    @commands.command()
    @commands.has_permissions(administrator=True)
    async def shutdown(self, ctx):
        """Vypne bota"""
        embed = discord.Embed(
            title="🔌 Vypínání bota",
            description="Bot se vypíná... 👋",
            color=self.discord_blue,
            timestamp=datetime.now()
        )
        embed.set_footer(text="TitanBot se bezpečně ukončuje")
        
        await ctx.send(embed=embed)
        await self.bot.close()

    # === INFO PŘÍKAZY ===

    @commands.command()
    async def info(self, ctx):
        """Informace o botovi"""
        try:
            embed = discord.Embed(
                title="🤖 TitanBot - Informace",
                description="Pokročilý Discord bot s monitoring a správou systému",
                color=self.discord_blue,
                timestamp=datetime.now()
            )
            
            embed.add_field(
                name="📊 Statistiky",
                value=(
                    f"🏛️ Servery: **{len(self.bot.guilds)}**\n"
                    f"👥 Uživatelé: **{len(self.bot.users)}**\n"
                    f"📝 Příkazy: **30+**\n"
                    f"🔧 Cogs: **{len(self.bot.cogs)}**"
                ),
                inline=True
            )
            
            embed.add_field(
                name="⚙️ Funkce",
                value=(
                    "🖥️ Server Monitoring\n"
                    "⭐ Leveling systém\n"
                    "🛡️ Moderace\n"
                    "🤖 AI asistent\n"
                    "🌐 Web Dashboard"
                ),
                inline=True
            )
            
            try:
                cpu_percent = psutil.cpu_percent()
                memory_percent = psutil.virtual_memory().percent
            except:
                cpu_percent = "N/A"
                memory_percent = "N/A"
            
            embed.add_field(
                name="💻 Systém",
                value=(
                    f"🐍 Python: **{sys.version_info.major}.{sys.version_info.minor}**\n"
                    f"📦 Discord.py: **{discord.__version__}**\n"
                    f"💾 RAM: **{memory_percent}%**\n"
                    f"⚡ CPU: **{cpu_percent}%**"
                ),
                inline=False
            )
            
            embed.add_field(
                name="🔗 Web Dashboard",
                value="**[localhost:5000](http://localhost:5000)**\nKomplexní správa přes web!",
                inline=False
            )
            
            if self.bot.user and self.bot.user.avatar:
                embed.set_thumbnail(url=self.bot.user.avatar.url)
            embed.set_footer(text="Made with ❤️ by Buzz", icon_url=ctx.author.display_avatar.url)
            
            await ctx.send(embed=embed)
        except Exception as e:
            await ctx.send(f"❌ Chyba při zobrazování info: {e}")

    # PING COMMAND ODSTRANĚN - už existuje jinde!

    # === MONITORING PŘÍKAZY ===

    @commands.command()
    async def processes(self, ctx):
        """Zobrazí top procesy"""
        try:
            embed = discord.Embed(
                title="⚙️ Top Procesy",
                color=self.discord_blue,
                timestamp=datetime.now()
            )
            
            processes = []
            for proc in psutil.process_iter(['pid', 'name', 'cpu_percent', 'memory_percent']):
                try:
                    proc_info = proc.info
                    if proc_info.get('cpu_percent') and proc_info['cpu_percent'] > 0.1:
                        processes.append(proc_info)
                except (psutil.NoSuchProcess, psutil.AccessDenied):
                    pass
            
            # Seřaď podle CPU a vezmi top 10
            processes.sort(key=lambda x: x.get('cpu_percent', 0), reverse=True)
            top_processes = processes[:10]
            
            process_text = ""
            for i, proc in enumerate(top_processes, 1):
                name = proc.get('name', 'Unknown')[:20]
                cpu = proc.get('cpu_percent', 0)
                memory = proc.get('memory_percent', 0)
                process_text += f"**{i}.** {name}\n"
                process_text += f"   🔸 CPU: {cpu:.1f}% | RAM: {memory:.1f}%\n\n"
            
            if not process_text:
                process_text = "Žádné procesy s vysokým využitím."
            
            embed.description = process_text[:4000]  # Discord limit
            embed.set_footer(text="Top 10 procesů podle CPU využití")
            
            await ctx.send(embed=embed)
        except Exception as e:
            await ctx.send(f"❌ Chyba při načítání procesů: {e}")

    @commands.command()
    async def cpuinfo(self, ctx):
        """Detailní info o CPU"""
        try:
            embed = discord.Embed(
                title="🖥️ CPU Informace",
                color=self.discord_blue,
                timestamp=datetime.now()
            )
            
            # Základní info
            cpu_count = psutil.cpu_count()
            cpu_count_logical = psutil.cpu_count(logical=True)
            cpu_percent = psutil.cpu_percent(interval=1)
            
            try:
                cpu_freq = psutil.cpu_freq()
                freq_current = cpu_freq.current if cpu_freq else 0
                freq_max = cpu_freq.max if cpu_freq and cpu_freq.max else 0
            except:
                freq_current = 0
                freq_max = 0
            
            processor_name = platform.processor()[:50] if platform.processor() else "Unknown"
            
            embed.add_field(
                name="📊 Základní informace",
                value=(
                    f"🔸 Fyzická jádra: **{cpu_count}**\n"
                    f"🔸 Logická jádra: **{cpu_count_logical}**\n"
                    f"🔸 Architektura: **{platform.machine()}**\n"
                    f"🔸 Procesor: **{processor_name}**"
                ),
                inline=False
            )
            
            freq_text = f"🔸 Frekvence: **{freq_current:.0f} MHz**\n" if freq_current else "🔸 Frekvence: **N/A**\n"
            if freq_max:
                freq_text += f"🔸 Max frekvence: **{freq_max:.0f} MHz**"
            else:
                freq_text += "🔸 Max frekvence: **N/A**"
            
            embed.add_field(
                name="⚡ Výkon",
                value=(
                    f"🔸 Využití: **{cpu_percent}%**\n"
                    f"{freq_text}"
                ),
                inline=False
            )
            
            # Per-core usage
            try:
                cpu_per_core = psutil.cpu_percent(percpu=True, interval=1)
                cores_text = ""
                for i, percent in enumerate(cpu_per_core[:8]):  # Max 8 jader pro zobrazení
                    cores_text += f"Jádro {i+1}: **{percent}%**\n"
                
                if cores_text:
                    embed.add_field(name="🔧 Využití jader", value=cores_text, inline=True)
            except:
                pass
            
            await ctx.send(embed=embed)
        except Exception as e:
            await ctx.send(f"❌ Chyba při načítání CPU info: {e}")

    @commands.command()
    async def meminfo(self, ctx):
        """Informace o paměti"""
        try:
            embed = discord.Embed(
                title="💾 Paměť (RAM)",
                color=self.discord_blue,
                timestamp=datetime.now()
            )
            
            # RAM
            memory = psutil.virtual_memory()
            total_gb = memory.total / (1024**3)
            used_gb = memory.used / (1024**3)
            available_gb = memory.available / (1024**3)
            
            ram_text = (
                f"🔸 Celkem: **{total_gb:.1f} GB**\n"
                f"🔸 Použito: **{used_gb:.1f} GB** ({memory.percent:.1f}%)\n"
                f"🔸 Dostupné: **{available_gb:.1f} GB**"
            )
            
            if hasattr(memory, 'cached'):
                ram_text += f"\n🔸 Cache: **{memory.cached / (1024**3):.1f} GB**"
            
            embed.add_field(
                name="📊 Virtuální paměť",
                value=ram_text,
                inline=False
            )
            
            # SWAP
            try:
                swap = psutil.swap_memory()
                if swap.total > 0:
                    swap_total_gb = swap.total / (1024**3)
                    swap_used_gb = swap.used / (1024**3)
                    
                    embed.add_field(
                        name="🔄 Swap paměť",
                        value=(
                            f"🔸 Celkem: **{swap_total_gb:.1f} GB**\n"
                            f"🔸 Použito: **{swap_used_gb:.1f} GB** ({swap.percent:.1f}%)"
                        ),
                        inline=True
                    )
            except:
                pass
            
            await ctx.send(embed=embed)
        except Exception as e:
            await ctx.send(f"❌ Chyba při načítání paměti: {e}")

    @commands.command()
    async def diskinfo(self, ctx):
        """Informace o discích"""
        try:
            embed = discord.Embed(
                title="💿 Disky",
                color=self.discord_blue,
                timestamp=datetime.now()
            )
            
            disk_partitions = psutil.disk_partitions()
            
            for partition in disk_partitions[:5]:  # Max 5 disků
                try:
                    usage = psutil.disk_usage(partition.mountpoint)
                    total_gb = usage.total / (1024**3)
                    used_gb = usage.used / (1024**3)
                    free_gb = usage.free / (1024**3)
                    percent = (used_gb / total_gb) * 100 if total_gb > 0 else 0
                    
                    embed.add_field(
                        name=f"💾 {partition.device}",
                        value=(
                            f"🔸 Systém: **{partition.fstype}**\n"
                            f"🔸 Celkem: **{total_gb:.1f} GB**\n"
                            f"🔸 Použito: **{used_gb:.1f} GB** ({percent:.1f}%)\n"
                            f"🔸 Volné: **{free_gb:.1f} GB**"
                        ),
                        inline=True
                    )
                except (PermissionError, OSError):
                    embed.add_field(
                        name=f"💾 {partition.device}",
                        value="❌ Nemám oprávnění",
                        inline=True
                    )
            
            await ctx.send(embed=embed)
        except Exception as e:
            await ctx.send(f"❌ Chyba při načítání disků: {e}")

    @commands.command()
    async def network(self, ctx):
        """Síťové statistiky"""
        try:
            embed = discord.Embed(
                title="🌐 Síť",
                color=self.discord_blue,
                timestamp=datetime.now()
            )
            
            # Síťové statistiky
            net_io = psutil.net_io_counters()
            
            sent_gb = net_io.bytes_sent / (1024**3)
            recv_gb = net_io.bytes_recv / (1024**3)
            
            embed.add_field(
                name="📊 Celkové statistiky",
                value=(
                    f"📤 Odesláno: **{sent_gb:.2f} GB**\n"
                    f"📥 Přijato: **{recv_gb:.2f} GB**\n"
                    f"📦 Pakety odeslané: **{net_io.packets_sent:,}**\n"
                    f"📦 Pakety přijaté: **{net_io.packets_recv:,}**"
                ),
                inline=False
            )
            
            if hasattr(net_io, 'errin') and hasattr(net_io, 'errout'):
                if net_io.errin or net_io.errout:
                    embed.add_field(
                        name="⚠️ Chyby",
                        value=(
                            f"❌ Chyby příjem: **{net_io.errin}**\n"
                            f"❌ Chyby odeslání: **{net_io.errout}**"
                        ),
                        inline=True
                    )
            
            # Síťová rozhraní
            try:
                net_if_addrs = psutil.net_if_addrs()
                interfaces_text = ""
                for interface_name, interface_addresses in list(net_if_addrs.items())[:3]:  # Max 3 rozhraní
                    for address in interface_addresses:
                        if hasattr(address, 'family') and address.family == 2:  # IPv4
                            interfaces_text += f"🔸 **{interface_name}**: {address.address}\n"
                            break
                
                if interfaces_text:
                    embed.add_field(name="🔌 Rozhraní", value=interfaces_text, inline=True)
            except:
                pass
            
            await ctx.send(embed=embed)
        except Exception as e:
            await ctx.send(f"❌ Chyba při načítání sítě: {e}")

    # === LEVELING PŘÍKAZ ===

    @commands.command()
    async def level(self, ctx, user: discord.Member = None):
        """Rychlé info o levelu"""
        if user is None:
            user = ctx.author
        
        # Načti leveling data
        try:
            with open("leveling_data.json", "r") as f:
                data = json.load(f)
            
            user_data = data.get(str(user.id), {"xp": 0, "level": 0, "messages": 0})
            
            embed = discord.Embed(
                title=f"⭐ Level - {user.display_name}",
                color=self.discord_blue
            )
            
            embed.add_field(name="📈 Level", value=f"**{user_data.get('level', 0)}**", inline=True)
            embed.add_field(name="⭐ XP", value=f"**{user_data.get('xp', 0):,}**", inline=True)
            embed.add_field(name="💬 Zprávy", value=f"**{user_data.get('messages', 0):,}**", inline=True)
            
            embed.set_thumbnail(url=user.display_avatar.url)
            
        except FileNotFoundError:
            embed = discord.Embed(
                title="❌ Leveling systém",
                description="Leveling data nejsou dostupná.",
                color=self.discord_blue
            )
        except Exception as e:
            embed = discord.Embed(
                title="❌ Chyba",
                description=f"Chyba při načítání dat: {e}",
                color=self.discord_blue
            )
        
        await ctx.send(embed=embed)

    # === MODERACE PŘÍKAZY === 
    # ODSTRAŇENO - už existuje v moderation.py

    # Odstraň tyto příkazy:
    # - clear
    # - purge  
    # - slowmode

    # === HELP COMMAND ===

    @commands.command(name="help")
    async def help_command(self, ctx, category=None):
        """Kompletní nápověda s kategoriemi"""
        try:
            load_dotenv(override=True)
            current_prefix = os.getenv("PREFIX", "!");
        except Exception:
            current_prefix = "!"

        try:
            if category is None:
                embed = discord.Embed(
                    title="🤖 TitanBot - Kompletní Nápověda",
                    description="Pokročilý Discord bot s monitoring, leveling a správou",
                    color=self.discord_blue,
                    timestamp=datetime.now()
                )

                if self.bot.user and self.bot.user.avatar:
                    embed.set_thumbnail(url=self.bot.user.avatar.url)

                embed.add_field(
                    name="📋 Kategorie příkazů",
                    value=(
                        f"`{current_prefix}help general` - 🔧 Obecné příkazy\n"
                        f"`{current_prefix}help admin` - ⚙️ Admin & správa\n"
                        f"`{current_prefix}help monitoring` - 🖥️ Server monitoring\n"
                        f"`{current_prefix}help leveling` - ⭐ Leveling systém\n"
                        f"`{current_prefix}help moderation` - 🛡️ Moderace (v jiném modulu)"
                    ),
                    inline=False
                )

                embed.add_field(
                    name="🌐 Web Dashboard",
                    value="**[localhost:5000](http://localhost:5000)**\nKomplexní správa přes webové rozhraní!",
                    inline=False
                )

                embed.add_field(
                    name="⚡ Nejpoužívanější příkazy",
                    value=(
                        f"`{current_prefix}ping` - Test odezvy (v jiném modulu)\n"
                        f"`{current_prefix}info` - Info o botovi\n"
                        f"`{current_prefix}rank` - Tvoje level\n"
                        f"`{current_prefix}monitoring` - Status serveru"
                    ),
                    inline=False
                )
                
            elif category.lower() == "general":
                embed = discord.Embed(title="🔧 Obecné příkazy", color=self.discord_blue)
                embed.add_field(
                    name="📊 Základní příkazy",
                    value=(
                        f"`{current_prefix}info` - Informace o botovi\n"
                        f"`{current_prefix}help [kategorie]` - Nápověda\n"
                        f"`{current_prefix}ai <otázka>` - AI asistent\n"
                        f"`{current_prefix}tf2` - TF2 video"
                    ),
                    inline=False
                )
                
            elif category.lower() == "admin":
                embed = discord.Embed(title="⚙️ Admin příkazy", color=self.discord_blue)
                embed.add_field(
                    name="🔧 Správa cogů",
                    value=(
                        f"`{current_prefix}load <cog>` - Načte modul\n"
                        f"`{current_prefix}unload <cog>` - Odpojí modul\n"
                        f"`{current_prefix}reload <cog>` - Znovu načte modul\n"
                        f"`{current_prefix}shutdown` - Vypne bota"
                    ),
                    inline=False
                )
                embed.add_field(
                    name="⚠️ Poznámky",
                    value="Pouze pro administrátory serveru!",
                    inline=False
                )
                
            elif category.lower() == "monitoring":
                embed = discord.Embed(title="🖥️ Server Monitoring", color=self.discord_blue)
                embed.add_field(
                    name="📊 Systémové informace",
                    value=(
                        f"`{current_prefix}monitoring` - Celkový přehled serveru\n"
                        f"`{current_prefix}processes` - Top běžící procesy\n"
                        f"`{current_prefix}cpuinfo` - Detailní info o CPU\n"
                        f"`{current_prefix}meminfo` - Využití paměti (RAM)\n"
                        f"`{current_prefix}diskinfo` - Informace o discích\n"
                        f"`{current_prefix}network` - Síťové statistiky"
                    ),
                    inline=False
                )
                embed.add_field(
                    name="🚨 Alerty",
                    value=(
                        f"`{current_prefix}testalert` - Test alert systému\n"
                        f"`{current_prefix}forcealert` - Vynutí kontrolu alertů\n"
                        f"`{current_prefix}reloadmonitoring` - Reload konfigurace"
                    ),
                    inline=False
                )
                embed.add_field(
                    name="🌐 Web interface",
                    value="Pokročilá konfigurace: **localhost:5000** → 🖥️ Monitoring",
                    inline=False
                )
                
            elif category.lower() == "leveling":
                embed = discord.Embed(title="⭐ Leveling Systém", color=self.discord_blue)
                embed.add_field(
                    name="👤 Uživatelské příkazy",
                    value=(
                        f"`{current_prefix}rank [@user]` - Zobrazí rank kartu\n"
                        f"`{current_prefix}leaderboard [stránka]` - Žebříček serveru\n"
                        f"`{current_prefix}level [@user]` - Rychlé info o levelu"
                    ),
                    inline=False
                )
                embed.add_field(
                    name="⚙️ Admin konfigurace",
                    value=(
                        f"`{current_prefix}levelconfig` - Hlavní konfigurace\n"
                        f"`{current_prefix}levelconfig enable/disable` - Zapne/vypne systém\n"
                        f"`{current_prefix}levelconfig xp <číslo>` - XP za zprávu\n"
                        f"`{current_prefix}levelconfig cooldown <sekundy>` - Cooldown\n"
                        f"`{current_prefix}levelconfig channel <#kanál>` - Level up kanál"
                    ),
                    inline=False
                )
                embed.add_field(
                    name="🎭 Role & Kanály",
                    value=(
                        f"`{current_prefix}levelconfig addrole <level> <@role>` - Přidá level roli\n"
                        f"`{current_prefix}levelconfig removerole <level>` - Odebere roli\n"
                        f"`{current_prefix}levelconfig blacklist <#kanál>` - Zakáže XP\n"
                        f"`{current_prefix}levelconfig multiplier <#kanál> <číslo>` - XP multiplikátor\n"
                        f"`{current_prefix}levelconfig reset <@user>` - Resetuje uživatele"
                    ),
                    inline=False
                )
                embed.add_field(
                    name="🔧 Správa XP",
                    value=(
                        f"`{current_prefix}addxp <@user> <číslo>` - Přidá XP\n"
                        f"`{current_prefix}removexp <@user> <číslo>` - Odebere XP"
                    ),
                    inline=False
                )
                embed.add_field(
                    name="🌐 Web konfigurace",
                    value="Pokročilé nastavení: **localhost:5000** → ⭐ Leveling",
                    inline=False
                )
                
            elif category.lower() == "moderation":
                embed = discord.Embed(title="🛡️ Moderace", color=self.discord_blue)
                embed.add_field(
                    name="ℹ️ Informace",
                    value="Moderace příkazy jsou v samostatném modulu `moderation.py`.\nPoužij `!help` v kanálu kde jsou aktivní.",
                    inline=False
                )
                embed.add_field(
                    name="🔧 Základní příkazy",
                    value=(
                        "• `clear` - Mazání zpráv\n"
                        "• `purge` - Mazání zpráv uživatele\n"
                        "• `slowmode` - Nastavení slowmode\n"
                        "• `ban`, `kick`, `timeout` - Sankce\n"
                        "• `warn` - Varování systém"
                    ),
                    inline=False
                )
                
            else:
                embed = discord.Embed(
                    title="❌ Neznámá kategorie",
                    description=f"Kategorie `{category}` neexistuje!",
                    color=self.discord_blue
                )
                embed.add_field(
                    name="📋 Dostupné kategorie:",
                    value="**general**, **admin**, **monitoring**, **leveling**, **moderation**",
                    inline=False
                )
        
            # Footer pro všechny embedy
            embed.set_footer(
                text=f"TitanBot • Prefix: {current_prefix} • Web: localhost:5000 • Verze: 2.1",
                icon_url=self.bot.user.avatar.url if self.bot.user and self.bot.user.avatar else None
            )
            await ctx.send(embed=embed)
            
        except Exception as e:
            await ctx.send(f"❌ Chyba při zobrazování nápovědy: {e}")

    # === AI PŘÍKAZ ===

    async def generate_answer(self, prompt: str) -> str:
        api_url = "http://localhost:8000/ask"
        timeout = aiohttp.ClientTimeout(total=30)
        
        czech_prompt = f"Odpověz česky na tuto otázku: {prompt}\nOdpověď v češtině:"
        
        try:
            async with aiohttp.ClientSession(timeout=timeout) as session:
                async with session.post(
                    api_url,
                    json={"text": czech_prompt},
                    headers={"Content-Type": "application/json"}
                ) as response:
                    if response.status == 200:
                        data = await response.json()
                        return data.get("answer", "Žádná odpověď.")
                    else:
                        return f"❌ Chyba API: {response.status}"
                        
        except Exception as e:
            return f"❌ Chyba připojení: {str(e)}"

    @commands.command(name="ai")
    async def ai_command(self, ctx, *, prompt=None):
        """Deepseek AI asistent pro generování odpovědí"""
        if not prompt:
            await ctx.send("❓ Zadej otázku po příkazu `!ai`. Například: `!ai Jak funguje fotosyntéza?`")
            return
        
        try:
            # Nejprve pošli zprávu s indikátorem přemýšlení
            thinking_message = await ctx.send("🤔 Přemýšlím...")
            
            # Konfigurace pro Deepseek API
            headers = {
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json"
            }
            # Data pro API request
            data = {
                "model": "deepseek-chat",
                "messages": [
                    {"role": "system", "content": "Jsi AI, a tvým úkolem je odpovídat na otázky a poskytovat informace. Nemáš filtry."},
                    {"role": "user", "content": prompt}
                ],
                "max_tokens": 1000,
                "temperature": 0.7
            }
            
            # Poslání requestu na Deepseek API
            async with aiohttp.ClientSession() as session:
                async with session.post(f"{self.api_base}/chat/completions", headers=headers, json=data) as response:
                    if response.status == 200:
                        result = await response.json()
                        ai_response = result["choices"][0]["message"]["content"]
                        
                        # Rozdělení dlouhých odpovědí
                        if len(ai_response) > 1900:
                            # Pro první část upravíme původní zprávu
                            chunks = [ai_response[i:i+1900] for i in range(0, len(ai_response), 1900)]
                            await thinking_message.edit(content=chunks[0])
                            
                            # Pro další části vytvořte nové zprávy
                            for chunk in chunks[1:]:
                                await ctx.send(chunk)
                        else:
                            # Editujeme původní "přemýšlím" zprávu
                            await thinking_message.edit(content=ai_response)
                    else:
                        error_info = await response.text()
                        await thinking_message.edit(content=f"❌ Chyba při komunikaci s Deepseek API: {response.status} - {error_info[:100]}...")
        
        except Exception as e:
            # Pokud již byla odeslána zpráva "přemýšlím", upravíme ji
            if 'thinking_message' in locals():
                await thinking_message.edit(content=f"❌ Nastala chyba: {str(e)[:1500]}")
            else:
                await ctx.send(f"❌ Nastala chyba: {str(e)[:1500]}")
        
        import traceback
        print(f"AI Command Error: {traceback.format_exc()}")

    @commands.command(name="img")
    async def generate_image(self, ctx, *, prompt: str):
        """Vygeneruje obrázek pomocí Replicate whiskii-gen"""
        msg = await ctx.send("🖼️ Generuji obrázek...")

        try:
            replicate_token = os.getenv("REPLICATE_API_TOKEN")
            os.environ["REPLICATE_API_TOKEN"] = replicate_token

            output = replicate.run(
                "qwen/qwen-image",
                input={
                        "prompt": prompt,
                        "go_fast": True,
                        "guidance": 4,
                        "strength": 0.9,
                        "image_size": "optimize_for_quality",
                        "lora_scale": 1,
                        "aspect_ratio": "16:9",
                        "output_format": "webp",
                        "enhance_prompt": False,
                        "output_quality": 80,
                        "negative_prompt": " ",
                        "num_inference_steps": 50
}
            )

            # Debug výpis
            print("Debug - Replicate output:", output)

            if output:
                # Získej URL přímo z výstupu
                image_url = output[0] if isinstance(output, list) else str(output)
                await msg.edit(content=image_url)
                return

            await msg.edit(content="❌ Replicate nevrátil platný obrázek.")
        except Exception as e:
            print(f"Debug - Error: {e}")  # Debug výpis chyby
            await msg.edit(content=f"❌ Chyba při generování obrázku: {e}")

async def setup(bot):
    await bot.add_cog(General(bot))