from flask import jsonify
import logging

logger = logging.getLogger(__name__)

def ping_command(data):
    """Handles the '/ping' command"""
    if data.get("type") == 1:
        logger.info("Responding to ping verification")
        return jsonify({"type": 1})

def settings_command(data):
    """Handles the '/settings' command"""
    if data.get("type") == 2:
        command = data.get("data", {}).get("name")
        logger.info(f"Received command: {command}")
        return jsonify({
            "type": 4,
            "data": {
                "content": "✅ Bot ist aktiv und verifiziert!"
            }
        })


## a) /balance user credits stand
## Dieser Befehl gibt den aktuellen Stand der Credits und Coins des Benutzers zurück. Dabei wird nur die anonyme ID des Benutzers verwendet, um den Punktestand abzurufen.
    def balance_command(user_id):
    # Angenommen, die Punkte werden in einer verschlüsselten Datenbank gespeichert
    user_data = get_user_data(user_id)  # Hier wird die Benutzer-ID verwendet, nicht der Name
    credits = user_data.get('credits', 0)
    coins = user_data.get('coins', 0)
    return jsonify({
        "type": 4,
        "data": {
            "content": f"Dein aktueller Kontostand: {credits} Credits, {coins} Coins"
        }
    })

# b) /send Money to user
# Dieser Befehl sendet eine bestimmte Menge Credits an einen anderen Benutzer. Hierbei müssen Sicherheitsvorkehrungen getroffen werden, um Missbrauch zu vermeiden, z. B.
# indem Transaktionen nur über den Bot und unter bestimmten Bedingungen durchgeführt werden.
def send_money_command(from_user_id, to_user_id, amount):
    if amount <= 0:
        return jsonify({"type": 4, "data": {"content": "Ungültiger Betrag!"}})
    
    # Überprüfe, ob der Absender genug Credits hat
    from_user_data = get_user_data(from_user_id)
    if from_user_data['credits'] < amount:
        return jsonify({"type": 4, "data": {"content": "Nicht genug Credits!"}})
    
    # Transaktion durchführen
    update_user_data(from_user_id, {'credits': from_user_data['credits'] - amount})
    to_user_data = get_user_data(to_user_id)
    update_user_data(to_user_id, {'credits': to_user_data['credits'] + amount})
    
    return jsonify({"type": 4, "data": {"content": f"Erfolgreich {amount} Credits an den Benutzer gesendet!"}})
    
# c) /daily (Tägliche Belohnung)
# Die tägliche Belohnung könnte beispielsweise 100 Credits pro Tag betragen. Eine Möglichkeit ist, den täglichen Bonus nur einmal pro Benutzer und Tag zu vergeben.
import datetime

def daily_reward(user_id):
    # Holen Sie sich das letzte Belohnungsdatum des Benutzers
    user_data = get_user_data(user_id)
    last_claimed = user_data.get('last_claimed', None)
    
    if last_claimed:
        # Überprüfen, ob der Benutzer heute schon seine Belohnung erhalten hat
        if last_claimed.date() == datetime.datetime.now().date():
            return jsonify({"type": 4, "data": {"content": "Du hast bereits deine tägliche Belohnung erhalten!"}})
    
    # Tägliche Belohnung vergeben
    new_credits = user_data.get('credits', 0) + 100  # Beispiel für eine tägliche Belohnung
    update_user_data(user_id, {'credits': new_credits, 'last_claimed': datetime.datetime.now()})
    
    return jsonify({"type": 4, "data": {"content": "Du hast deine tägliche Belohnung erhalten: 100 Credits!"}})

# d) /fish (Fischen)
# Beim Fischen gibt es zwei Orte, z. B. einen See und einen Fluss. Der Fluss könnte weniger große, aber günstigere Fische bringen, während der See größere, aber gefährlichere Fische bietet. 
# Wenn der Benutzer Pech hat, könnte er Credits verlieren. Hier ein Beispiel, wie das Fischen implementiert werden könnte:
import random

def fish_command(user_id, location):
    # Überprüfe, ob der Benutzer genug Credits für das Fischen hat
    user_data = get_user_data(user_id)
    if user_data['credits'] < 10:  # Beispiel: Fischen kostet 10 Credits
        return jsonify({"type": 4, "data": {"content": "Nicht genug Credits zum Fischen!"}})
    
    # Wähle das Ergebnis basierend auf dem Ort
    if location == "river":
        chance = random.randint(1, 100)
        if chance <= 70:  # 70% Chance, einen kleinen Fisch zu fangen
            reward = 20  # Der Benutzer verdient 20 Credits
        else:
            reward = -10  # 30% Chance, einen Unfall zu haben und Credits zu verlieren
    elif location == "lake":
        chance = random.randint(1, 100)
        if chance <= 50:  # 50% Chance, einen großen Fisch zu fangen
            reward = 50  # Der Benutzer verdient 50 Credits
        else:
            reward = -30  # 50% Chance auf einen Unfall und Verlust von Credits
    
    # Fische und aktualisiere die Credits
    new_credits = user_data.get('credits', 0) + reward
    update_user_data(user_id, {'credits': new_credits})
    
    return jsonify({
        "type": 4,
        "data": {"content": f"Du hast {reward} Credits gefangen!" if reward >= 0 else f"Du hast {abs(reward)} Credits verloren!"}
    })

# Der Shop
def shop_command(user_id, item):
    # Shop-Preise definieren
    items = {
        "avatar1": 100,
        "avatar2": 150,
        "role1": 200,
        "exclusive_channel_access": 300
    }
    
    if item not in items:
        return jsonify({"type": 4, "data": {"content": "Ungültiger Artikel!"}})
    
    item_price = items[item]
    user_data = get_user_data(user_id)
    
    # Überprüfen, ob der Benutzer genug Credits hat
    if user_data['credits'] < item_price:
        return jsonify({"type": 4, "data": {"content": "Nicht genug Credits für diesen Artikel!"}})
    
    # Artikel kaufen
    update_user_data(user_id, {'credits': user_data['credits'] - item_price})
    
    # Artikel freischalten (z. B. Rolle oder Avatar)
    unlock_item(user_id, item)
    
    return jsonify({"type": 4, "data": {"content": f"Du hast erfolgreich {item} gekauft!"}})