import os
import re
import sqlite3
import asyncio
import openai
import sys
import subprocess

from google import genai
from google.genai import types

from datetime import datetime
from pathlib import Path
from dotenv import load_dotenv

from colorama import init, Fore, Style


# ====================================================
# INITIALISIERUNG
# ====================================================

init(autoreset=True)


# ====================================================
# PFADE & SETUP
# ====================================================

BASE_DIR = Path(__file__).resolve().parent
CONFIG_DIR = BASE_DIR / "config"
DATA_DIR = BASE_DIR / "data"
WORKSPACE_DIR = BASE_DIR / "workspace"

ENV_FILE = CONFIG_DIR / ".env"
load_dotenv(ENV_FILE)

DB_PATH = DATA_DIR / "cluster.db"
NOTES_FILE = WORKSPACE_DIR / "NOTIZEN.md"
TODO_FILE = WORKSPACE_DIR / "TODO.md"
CHAT_LOG_FILE = WORKSPACE_DIR / "chat_history.log"

WEB_USER_NAME = os.getenv("WEB_USER_NAME", "Meik")


# ====================================================
# TERMINAL FARBEN
# ====================================================

USER_COLOR = Fore.CYAN
JARVIS_COLOR = Fore.GREEN
SYSTEM_COLOR = Fore.YELLOW
ERROR_COLOR = Fore.RED
OUTPUT_COLOR = Fore.MAGENTA
INFO_COLOR = Fore.BLUE

RESET = Style.RESET_ALL


# ====================================================
# ORDNER & DATEIEN
# ====================================================

for d in [WORKSPACE_DIR, DATA_DIR, CONFIG_DIR]:
    d.mkdir(parents=True, exist_ok=True)

for f in [NOTES_FILE, TODO_FILE]:
    if not f.exists():
        f.write_text(
            f"# {f.name}\nHier fängt dein Gedächtnis an, J.A.R.V.I.S.\n",
            encoding="utf-8"
        )


# ====================================================
# KI KONFIGURATION
# ====================================================

AI_PROVIDER = os.getenv("AI_PROVIDER", "google").lower()

OPENAI_API_KEY = os.getenv("OPENAI_API_KEY", "")
GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY", "")
NVIDIA_API_KEY = os.getenv("NVIDIA_API_KEY", "")
GROQ_API_KEY = os.getenv("GROQ_API_KEY", "")
OLLAMA_BASE_URL = os.getenv(
    "OLLAMA_BASE_URL",
    "http://127.0.0.1:11434/v1"
)

GOOGLE_MODEL = os.getenv(
    "GOOGLE_MODEL",
    "gemini-2.5-flash"
)

OPENAI_MODEL = os.getenv(
    "OPENAI_MODEL",
    "gpt-4o"
)

OLLAMA_MODEL = os.getenv(
    "OLLAMA_MODEL",
    "llama3"
)

NVIDIA_MODEL = os.getenv(
    "NVIDIA_MODEL",
    "moonshotai/kimi-k2.6"
)

GROQ_MODEL = os.getenv(
    "GROQ_MODEL",
    "meta-llama/llama-4-scout-17b-16e-instruct"
)

# ====================================================
# DATENBANK
# ====================================================

def init_db():
    conn = sqlite3.connect(DB_PATH)

    conn.execute('''
        CREATE TABLE IF NOT EXISTS nodes (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT,
            ip TEXT UNIQUE,
            user TEXT,
            sudo_password TEXT,
            os TEXT DEFAULT 'Unbekannt',
            arch TEXT DEFAULT 'Unbekannt',
            docker_installed INTEGER DEFAULT 0,
            status TEXT
        )
    ''')

    conn.commit()
    conn.close()


init_db()


def get_db():
    conn = sqlite3.connect(DB_PATH)
    conn.row_factory = sqlite3.Row
    return conn

# ====================================================
# DYNAMISCHE PROGRAMM-ERKENNUNG (NEU)
# ====================================================

def get_installed_gui_apps():
    """Scannt das System nach installierten GUI-Programmen und deren Befehlen."""
    apps_dir = Path("/usr/share/applications")
    detected_apps = {}
    
    if apps_dir.exists():
        for desktop_file in apps_dir.glob("*.desktop"):
            try:
                # Wir lesen die .desktop Datei aus
                content = desktop_file.read_text(encoding="utf-8", errors="ignore")
                
                # Suchen nach Name und Exec-Befehl
                name_match = re.search(r"^Name=(.+)$", content, re.M)
                exec_match = re.search(r"^Exec=([^ \n%]+)", content, re.M) # Nur den reinen Befehl ohne Argumente (%U etc.)
                
                if name_match and exec_match:
                    app_name = name_match.group(1).strip()
                    app_cmd = exec_match.group(1).strip()
                    
                    # Ignoriere Core-Systemkram, der Meik nur nerven würde
                    if not any(x in app_cmd.lower() for x in ["debian", "im-config", "openjdk", "systemd"]):
                        detected_apps[app_name] = app_cmd
            except Exception:
                continue
                
    return detected_apps


# ====================================================
# SYSTEM PROMPT
# ====================================================

def get_system_prompt():

    prompt_path = CONFIG_DIR / "system_prompt.txt"

    prompt = (
        prompt_path.read_text(encoding="utf-8")
        if prompt_path.exists()
        else f"Hallo {WEB_USER_NAME}, ich bin J.A.R.V.I.S."
    )

    prompt = prompt.replace("{user_name}", WEB_USER_NAME)
    prompt = prompt.replace("{workspace_dir}", str(WORKSPACE_DIR))
    prompt = prompt.replace("{notes_file}", str(NOTES_FILE))
    prompt = prompt.replace("{todo_file}", str(TODO_FILE))

    # --- DYNAMISCHE PROGRAMME INJIZIEREN ---
    installed_apps = get_installed_gui_apps()
    apps_prompt_string = "VERFÜGBARE LOKALE DESKTOP-PROGRAMME (Nutze NUR diese Befehe zum Starten!):\n"
    for app_name, app_cmd in installed_apps.items():
        apps_prompt_string += f"- {app_name}: Befehl lautet '{app_cmd}'\n"
        
    # Wir hängen die Liste einfach an den Prompt an oder ersetzen einen Platzhalter
    if "{installed_apps}" in prompt:
        prompt = prompt.replace("{installed_apps}", apps_prompt_string)
    else:
        prompt += "\n\n" + apps_prompt_string
    # ---------------------------------------

    conn = get_db()
    nodes = conn.execute('SELECT * FROM nodes').fetchall()
    conn.close()

    node_info = ""
    for n in nodes:
        node_info += f"- Name: {n['name']}, IP: {n['ip']}, User: {n['user']}\n"

    return prompt.replace("{node_info}", node_info)

# ====================================================
# KI KOMMUNIKATION
# ====================================================

async def get_ai_response(user_msg, system_prompt, history_list):

    try:

        if AI_PROVIDER in ["openai", "ollama", "nvidia", "groq"]:

            # ========================================
            # PAYLOAD WASCHEN (Für strikte APIs wie Groq)
            # ========================================
            clean_history = [
                {
                    "role": msg["role"], 
                    "content": msg["content"]
                }
                for msg in history_list
            ]

            messages = [
                {
                    "role": "system",
                    "content": system_prompt
                }
            ] + clean_history

            if AI_PROVIDER == "ollama":

                url = (
                    OLLAMA_BASE_URL
                    if OLLAMA_BASE_URL.endswith('/v1')
                    else OLLAMA_BASE_URL.rstrip('/') + '/v1'
                )

                key = "ollama"
                model_to_use = OLLAMA_MODEL

            elif AI_PROVIDER == "nvidia":

                url = "https://integrate.api.nvidia.com/v1"
                key = NVIDIA_API_KEY
                model_to_use = NVIDIA_MODEL
                
            elif AI_PROVIDER == "groq":
                url = "https://api.groq.com/openai/v1"
                key = GROQ_API_KEY
                model_to_use = GROQ_MODEL

            else:

                url = None
                key = OPENAI_API_KEY
                model_to_use = OPENAI_MODEL

            client = openai.AsyncOpenAI(
                base_url=url,
                api_key=key
            )

            response = await client.chat.completions.create(
                model=model_to_use,
                messages=messages
            )

            return response.choices[0].message.content

        elif AI_PROVIDER == "google":

            client = genai.Client(api_key=GOOGLE_API_KEY)

            google_history = [
                types.Content(
                    role="user" if msg["role"] == "user" else "model",
                    parts=[
                        types.Part.from_text(
                            text=msg["content"]
                        )
                    ]
                )
                for msg in history_list[:-1]
            ]

            chat = client.chats.create(
                model=GOOGLE_MODEL,
                config=types.GenerateContentConfig(
                    system_instruction=system_prompt
                ),
                history=google_history
            )

            return chat.send_message(user_msg).text

    except Exception as e:

        return f"Fehler bei der KI-Anfrage: {e}"


# ====================================================
# BEFEHLSAUSFÜHRUNG
# ====================================================

async def run_task(target, cmd):

    print(
        f"\n{SYSTEM_COLOR}"
        f"⚙️  STARTE TASK AUF [{target}]"
        f"{RESET}"
    )

    print(
        f"{INFO_COLOR}"
        f"➡️  {cmd}"
        f"{RESET}\n"
    )

    try:

        # ========================================
        # GUI APPS ERKENNEN
        # ========================================

        # Holt sich alle bekannten System-GUI-Befehle dynamisch
        gui_apps = list(get_installed_gui_apps().values())

        first_word = cmd.strip().split()[0]

        is_gui_app = (
            first_word in gui_apps
            or cmd.strip().endswith("&")
        )

        # ========================================
        # GUI APPS DETACHED STARTEN
        # ========================================

        if is_gui_app:

            detached_cmd = (
                f"nohup {cmd.replace('&', '').strip()} "
                f">/dev/null 2>&1 &"
            )

            print(
                f"{SYSTEM_COLOR}"
                f"🖥️ GUI-APP erkannt → Detached Mode"
                f"{RESET}"
            )

            if target.lower() in ["localhost", "127.0.0.1"]:

                proc = await asyncio.create_subprocess_shell(
                    detached_cmd
                )

            else:

                conn = get_db()

                n = conn.execute(
                    'SELECT * FROM nodes WHERE ip=? OR name=?',
                    (target, target)
                ).fetchone()

                conn.close()

                if not n:

                    err = (
                        f"Node '{target}' "
                        f"nicht gefunden."
                    )

                    print(
                        f"{ERROR_COLOR}{err}{RESET}"
                    )

                    return err

                ssh_cmd = (
                    f"ssh "
                    f"-o StrictHostKeyChecking=no "
                    f"-o LogLevel=ERROR "
                    f"{n['user']}@{n['ip']} "
                    f"'{detached_cmd}'"
                )

                proc = await asyncio.create_subprocess_shell(
                    ssh_cmd
                )

            await proc.wait()

            print(
                f"{JARVIS_COLOR}"
                f"✅ GUI-Programm gestartet"
                f"{RESET}\n"
            )

            return "GUI application started."

        # ========================================
        # NORMALE COMMANDS
        # ========================================

        else:

            if target.lower() in ["localhost", "127.0.0.1"]:

                final_cmd = cmd

            else:

                conn = get_db()

                n = conn.execute(
                    'SELECT * FROM nodes WHERE ip=? OR name=?',
                    (target, target)
                ).fetchone()

                conn.close()

                if not n:

                    err = (
                        f"Node '{target}' "
                        f"nicht gefunden."
                    )

                    print(
                        f"{ERROR_COLOR}{err}{RESET}"
                    )

                    return err

                final_cmd = (
                    f"ssh "
                    f"-o StrictHostKeyChecking=no "
                    f"-o LogLevel=ERROR "
                    f"{n['user']}@{n['ip']} "
                    f"'{cmd}'"
                )

            proc = await asyncio.create_subprocess_shell(
                final_cmd,
                stdout=asyncio.subprocess.PIPE,
                stderr=asyncio.subprocess.STDOUT
            )

            collected_output = []

            # ========================================
            # KRISENFESTES AUSLESEN MIT TIMEOUT
            # ========================================
            try:
                while True:
                    # Warte maximal 2 Sekunden auf die nächste Zeile
                    line = await asyncio.wait_for(proc.stdout.readline(), timeout=2.0)
                    
                    if not line:
                        break

                    decoded = line.decode("utf-8", errors="ignore").rstrip()
                    collected_output.append(decoded)

                    print(f"{OUTPUT_COLOR}│ {decoded}{RESET}")
            except asyncio.TimeoutError:
                # Falls das Tool die Pipe offen hält, lesen wir einfach nicht weiter
                print(f"{SYSTEM_COLOR}⏳ Ausgabe-Stream stagniert. Erzwinge Prozess-Check...{RESET}")

            # Maximal 2 Sekunden auf das offizielle Ende des Prozesses warten
            try:
                await asyncio.wait_for(proc.wait(), timeout=2.0)
            except asyncio.TimeoutError:
                print(f"{ERROR_COLOR}⚠️ Prozess reagiert nicht. Setze Ablauf trotzdem fort.{RESET}")
                # Optional: proc.terminate() falls du ihn hart killen willst

            print()

    except Exception as e:

        err = f"❌ Fehler: {e}"

        print(
            f"{ERROR_COLOR}"
            f"{err}"
            f"{RESET}\n"
        )

        return err

# ====================================================
# FILE LOGGING
# ====================================================
def log_to_file(role, content):
    now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    try:
        with open(CHAT_LOG_FILE, "a", encoding="utf-8") as f:
            f.write(f"[{now}] {role.upper()}:\n{content}\n{'-'*60}\n")
    except Exception as e:
        print(f"{ERROR_COLOR}⚠️ Konnte nicht ins Log schreiben: {e}{RESET}")

# ====================================================
# USER INPUT
# ====================================================

async def listen_to_user():

    return await asyncio.to_thread(
        input,
        f"\n{USER_COLOR}👤 Du:{RESET} "
    )


# ====================================================
# JARVIS OUTPUT
# ====================================================

async def speak_to_user(text):
    print(f"\n{JARVIS_COLOR}🤖 J.A.R.V.I.S.{RESET}")
    print(f"{JARVIS_COLOR}{'-'*60}{RESET}")
    print(text)
    print(f"{JARVIS_COLOR}{'-'*60}{RESET}\n")

    clean_text = re.sub(r'[^\w\s\d.,!?-]', '', text)
    
    piper_path = "/home/meik/jarvis-ai/piper/piper"
    model_path = "/home/meik/jarvis-ai/de_DE-thorsten-high.onnx"
    lock_file = Path("/tmp/.jarvis_speaking") # Die Sperr-Datei

    if os.path.exists(piper_path) and os.path.exists(model_path):
        try:
            # 1. Sperre setzen
            lock_file.touch()
            
            piper_cmd = f"echo '{clean_text}' | {piper_path} --model {model_path} --output_raw | aplay -r 22050 -f S16_LE -t raw -D pipewire >/dev/null 2>&1"
            
            proc = await asyncio.create_subprocess_shell(piper_cmd)
            await proc.wait()
            
        except Exception as e:
            print(f"⚠️ TTS Fehler: {e}")
        finally:
            # 2. Sperre IMMER wieder aufheben, wenn Piper fertig ist
            if lock_file.exists():
                lock_file.unlink()

# ====================================================
# MAIN LOOP
# ====================================================

async def main_chat_loop():

    print(f"{INFO_COLOR}")

    print("====================================================")
    print("🤖 J.A.R.V.I.S. Terminal Interface geladen")
    print(f"🧠 Provider: {AI_PROVIDER.upper()}")
    print("⌨️  Tippe 'exit', um zu beenden")
    print("====================================================")

    print(RESET)

    chat_history = []

    while True:

        user_msg = await listen_to_user()

        if user_msg.lower().strip() in ['exit', 'quit']:

            print(
                f"{SYSTEM_COLOR}"
                f"\nJ.A.R.V.I.S. geht offline."
                f"{RESET}"
            )

            break

        if not user_msg.strip():
            continue

        now = datetime.now().strftime("%d.%m.%Y %H:%M")

        chat_history.append({
            "role": "user",
            "content": user_msg,
            "timestamp": now
        })
        
        # LOG: User Eingabe hier schreiben!
        log_to_file("Du", user_msg)

        print(
            f"{SYSTEM_COLOR}"
            f"🧠 J.A.R.V.I.S. denkt nach..."
            f"{RESET}",
            end="\r"
        )

        system_prompt = get_system_prompt()

        ai_response = await get_ai_response(
            user_msg,
            system_prompt,
            chat_history
        )

        # ============================================
        # EXECUTE TAGS SUCHEN
        # Unterstützt:
        # <EXECUTE>cmd</EXECUTE>
        # <EXECUTE target="xyz">cmd</EXECUTE>
        # ============================================
        
        commands = []
        
        # Toleranter Regex: Erlaubt Leerzeichen vor dem '>'
        execute_matches = re.finditer(
            r'<EXECUTE[^>]*?(?:target="(.*?)")?[^>]*>(.*?)</EXECUTE>',
            ai_response,
            re.I | re.S
        )
        
        for match in execute_matches:
            target = match.group(1)
            cmd = match.group(2)
            
            if not target:
                target = "localhost"
                
            # Markdown-Backticks bereinigen, falls die KI sie in den Tag mogelt
            cmd = cmd.strip()
            cmd = re.sub(r'^```[a-zA-Z]*\n?', '', cmd)
            cmd = re.sub(r'\n?```$', '', cmd)
            cmd = cmd.strip()
            
            commands.append((target.strip(), cmd))
        
        # Die Tags für die Sprach-/Textausgabe sauber entfernen
        clean_msg = re.sub(
            r'<EXECUTE[^>]*?>.*?</EXECUTE>',
            '',
            ai_response,
            flags=re.I | re.S
        ).strip()
        
        # ============================================
        # JARVIS TEXT
        # ============================================

        if clean_msg:

            await speak_to_user(clean_msg)

            chat_history.append({
                "role": "assistant",
                "content": clean_msg,
                "timestamp": now
            })
            
            # LOG: Jarvis Antwort hier schreiben!
            log_to_file("J.A.R.V.I.S.", clean_msg)

        # ============================================
        # COMMANDS AUSFÜHREN
        # ============================================

        if commands:

          for target, cmd in commands:

            target = target.strip()
            cmd = cmd.strip()

            action_msg = (
                f"⚙️ Ich führe jetzt folgenden Befehl "
                f"auf [{target}] aus:\n\n"
                f"{cmd}"
            )

            # ÄNDERUNG: Auch hier nur im Terminal anzeigen, NICHT vorlesen!
            print(f"\n{SYSTEM_COLOR}{action_msg}{RESET}\n")
            log_to_file("SYSTEM", action_msg)

            # ========================================
            # COMMAND AUSFÜHREN
            # ========================================

            output = await run_task(
                target,
                cmd
            )

            # ========================================
            # OUTPUT IM CHAT SICHTBAR MACHEN
            # ========================================

            if output:
                output_msg = (
                    f"💻 Ergebnis der Ausführung "
                    f"auf [{target}]:\n\n"
                    f"{output}"
                )
            else:
                output_msg = (
                    f"✅ Befehl auf [{target}] "
                    f"erfolgreich abgeschlossen."
                )

            # Das hier wird weiterhin laut vorgelesen!
            await speak_to_user(output_msg)

            sys_now = datetime.now().strftime("%d.%m.%Y %H:%M")
            chat_history.append({
                "role": "assistant",
                "content": output_msg,
                "timestamp": sys_now
            })
            log_to_file("SYSTEM", output_msg)

        # ============================================
        # HISTORY LIMIT
        # ============================================

        if len(chat_history) > 20:
            chat_history = chat_history[-20:]



# ====================================================
# EINZEL-BEFEHL MODUS (Für das Sprachskript)
# ====================================================
async def run_single_command(command_text):
    """Verarbeitet einen einzelnen Befehl von außen und beendet sich wieder."""
    init_db()
    system_prompt = get_system_prompt()
    
    # Wir tun so, als käme die Eingabe aus dem Chat-History-Verlauf
    now = datetime.now().strftime("%d.%m.%Y %H:%M")
    chat_history = [{
        "role": "user",
        "content": command_text,
        "timestamp": now
    }]
    
    log_to_file("Voice-Input", command_text)
    
    ai_response = await get_ai_response(
        command_text,
        system_prompt,
        chat_history
    )
    
    if ai_response is None:
        return

    # EXECUTE-Tags suchen und ausführen
    commands = []
    execute_matches = re.finditer(
        r'<EXECUTE[^>]*?(?:target="(.*?)")?[^>]*>(.*?)</EXECUTE>',
        ai_response,
        re.I | re.S
    )

    for match in execute_matches:
        target = match.group(1) or "localhost"
        cmd = match.group(2).strip()
        cmd = re.sub(r'^```[a-zA-Z]*\n?', '', cmd)
        cmd = re.sub(r'\n?```$', '', cmd)
        commands.append((target.strip(), cmd.strip()))

    clean_msg = re.sub(r'<EXECUTE[^>]*?>.*?</EXECUTE>', '', ai_response, flags=re.I | re.S).strip()
    
    if clean_msg:
        await speak_to_user(clean_msg)
        log_to_file("J.A.R.V.I.S.", clean_msg)

    if commands:
        for target, cmd in commands:
            action_msg = f"⚙️ Führe Sprachbefehl auf [{target}] aus:\n{cmd}"
            
            # ÄNDERUNG: Nur im Terminal anzeigen, NICHT vorlesen!
            print(f"\n{SYSTEM_COLOR}{action_msg}{RESET}\n")
            log_to_file("SYSTEM", action_msg)
            
            # Befehl im Hintergrund ausführen
            await run_task(target, cmd)

# ====================================================
# START
# ====================================================
if __name__ == "__main__":
    try:
        # Wenn Argumente übergeben wurden (z.B. python3 jarvis.py --voice-cmd "...")
        if len(sys.argv) > 2 and sys.argv[1] == "--voice-cmd":
            command_text = sys.argv[2]
            asyncio.run(run_single_command(command_text))
        else:
            # Normaler Terminal-Modus
            asyncio.run(main_chat_loop())
    except KeyboardInterrupt:
        print(f"\n{ERROR_COLOR}⛔ J.A.R.V.I.S. hart beendet.{RESET}")