app/bank.py

from flask import jsonify
from datetime import datetime, timedelta

class BankAccount:
    def __init__(self, user_id, balance=0.0, interest_rate=0.0):
        if not isinstance(user_id, (int, str)):
            raise ValueError("user_id muss eine Zahl oder String sein")
        if balance < 0:
            raise ValueError("Startguthaben kann nicht negativ sein")
        
        self.user_id = user_id
        self.balance = float(balance)
        self.interest_rate = float(interest_rate)
        self.last_interest_time = datetime.now()
        self.transaction_history = []

    def add_transaction(self, transaction_type, amount, description=""):
        transaction = {
            "timestamp": datetime.now(),
            "type": transaction_type,
            "amount": amount,
            "balance_after": self.balance,
            "description": description
        }
        self.transaction_history.append(transaction)

    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("Einzahlungsbetrag muss positiv sein.")
        self.balance += amount
        self.add_transaction("deposit", amount)
        return self.balance

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError("Abhebungsbetrag muss positiv sein.")
        if amount > self.balance:
            raise ValueError("Nicht genügend Geld auf dem Konto.")
        self.balance -= amount
        self.add_transaction("withdraw", amount)
        return self.balance

    def apply_interest(self):
        current_time = datetime.now()
        time_difference = current_time - self.last_interest_time
        
        if time_difference >= timedelta(days=1):
            days_passed = time_difference.days
            old_balance = self.balance
            self.balance *= (1 + self.interest_rate) ** days_passed
            interest_earned = self.balance - old_balance
            
            self.add_transaction("interest", interest_earned, 
                               f"Zinsen für {days_passed} Tage")
            self.last_interest_time = current_time
        
        return self.balance

    def get_balance(self):
        self.apply_interest()
        return self.balance

    def get_transaction_history(self):
        return self.transaction_history

    def transfer(self, target_account, amount):
        if not isinstance(target_account, BankAccount):
            raise ValueError("Ungültiges Zielkonto")
        self.withdraw(amount)
        target_account.deposit(amount)
        self.add_transaction("transfer_out", amount, f"Transfer an {target_account.user_id}")
        target_account.add_transaction("transfer_in", amount, f"Transfer von {self.user_id}")

    def format_balance(self):
        return f"{self.balance:,.2f} Credits"

class BankSystem:
    def __init__(self):
        self.accounts = {}
        
    def create_account(self, user_id, initial_balance=0.0, interest_rate=0.05):
        if user_id in self.accounts:
            raise ValueError("Konto existiert bereits")
        account = BankAccount(user_id, initial_balance, interest_rate)
        self.accounts[user_id] = account
        return account
    
    def get_account(self, user_id):
        return self.accounts.get(user_id)
    
    def transfer_between_accounts(self, from_user_id, to_user_id, amount):
        from_account = self.get_account(from_user_id)
        to_account = self.get_account(to_user_id)
        if not from_account or not to_account:
            raise ValueError("Ein oder beide Konten existieren nicht")
        from_account.transfer(to_account, amount)

def send_money_command(from_user_id, to_user_id, amount):
    if amount <= 0:
        return jsonify({"type": 4, "data": {"content": "Ungültiger Betrag!"}})
    
    try:
        # Ü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})
        
        # Transaktion in History dokumentieren
        transaction_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        log_transaction(from_user_id, to_user_id, amount, transaction_time)
        
        return jsonify({
            "type": 4, 
            "data": {
                "content": f"Erfolgreich {amount:,.2f} Credits an den Benutzer {to_user_id} gesendet!"
            }
        })
    
    except Exception as e:
        logging.error(f"Fehler bei der Überweisung: {str(e)}")
        return jsonify({
            "type": 4, 
            "data": {
                "content": "Ein Fehler ist bei der Überweisung aufgetreten!"
            }
        })

def daily_reward(user_id):
    """Gives daily reward of 100 credits to the user"""
    try:
        user_data = get_user_data(user_id)
        last_claimed = user_data.get('last_claimed', None)
        
        if last_claimed:
            last_claimed_date = datetime.fromisoformat(str(last_claimed))
            if last_claimed_date.date() == datetime.now().date():
                return jsonify({
                    "type": 4, 
                    "data": {
                        "content": "Du hast bereits deine tägliche Belohnung erhalten!"
                    }
                })
        
        # Zufällige Belohnung zwischen 50 und 150 Credits
        reward_amount = random.randint(50, 150)
        new_credits = user_data.get('credits', 0) + reward_amount
        
        # Update user data
        update_user_data(user_id, {
            'credits': new_credits,
            'last_claimed': datetime.now()
        })
        
        return jsonify({
            "type": 4,
            "data": {
                "content": f"Du hast deine tägliche Belohnung erhalten: {reward_amount} Credits!"
            }
        })
    
    except Exception as e:
        logging.error(f"Fehler bei der täglichen Belohnung: {str(e)}")
        return jsonify({
            "type": 4,
            "data": {
                "content": "Ein Fehler ist beim Abholen der täglichen Belohnung aufgetreten!"
            }
        })

# Hilfsfunktionen (müssen implementiert werden)
def get_user_data(user_id):
    """Implementiere diese Funktion, um Benutzerdaten aus der Datenbank zu holen"""
    pass

def update_user_data(user_id, data):
    """Implementiere diese Funktion, um Benutzerdaten in der Datenbank zu aktualisieren"""
    pass
def log_transaction(from_user_id, to_user_id, amount, timestamp):
    """Implementiere diese Funktion, um Transaktionen in einem Log festzuhalten"""
    try:
        transaction_log = {
            "from_user": from_user_id,
            "to_user": to_user_id,
            "amount": amount,
            "timestamp": timestamp,
            "transaction_id": generate_transaction_id()
        }
        
        # Hier könnte die Speicherung in einer Datenbank erfolgen
        save_transaction_to_db(transaction_log)
        
        logging.info(f"Transaktion erfolgreich protokolliert: {transaction_log}")
        return True
    
    except Exception as e:
        logging.error(f"Fehler beim Protokollieren der Transaktion: {str(e)}")
        return False

def generate_transaction_id():
    """Generiert eine einzigartige Transaktions-ID"""
    timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
    random_suffix = ''.join(random.choices('0123456789ABCDEF', k=6))
    return f"TRX-{timestamp}-{random_suffix}"

def save_transaction_to_db(transaction_data):
    """Implementiere diese Funktion zur Speicherung in der Datenbank"""
    pass

def get_user_transaction_history(user_id):
    """Gibt die Transaktionshistorie eines Benutzers zurück"""
    try:
        # Implementiere hier die Datenbankabfrage
        transactions = []  # Hole Transaktionen aus der Datenbank
        return jsonify({
            "type": 4,
            "data": {
                "content": "Transaktionshistorie",
                "transactions": transactions
            }
        })
    except Exception as e:
        logging.error(f"Fehler beim Abrufen der Transaktionshistorie: {str(e)}")
        return jsonify({
            "type": 4,
            "data": {
                "content": "Fehler beim Abrufen der Transaktionshistorie"
            }
        })

def check_account_status(user_id):
    """Überprüft den Status eines Bankkontos"""
    try:
        user_data = get_user_data(user_id)
        account = BankAccount(user_id, user_data.get('credits', 0))
        
        status_info = {
            "balance": account.format_balance(),
            "last_transaction": user_data.get('last_transaction'),
            "account_age": calculate_account_age(user_data.get('created_at')),
            "interest_rate": f"{account.interest_rate * 100}%"
        }
        
        return jsonify({
            "type": 4,
            "data": {
                "content": "Kontostatus",
                "status": status_info
            }
        })
    except Exception as e:
        logging.error(f"Fehler beim Abrufen des Kontostatus: {str(e)}")
        return jsonify({
            "type": 4,
            "data": {
                "content": "Fehler beim Abrufen des Kontostatus"
            }
        })

def calculate_account_age(created_at):
    """Berechnet das Alter eines Kontos"""
    if not created_at:
        return "Unbekannt"
    
    created_date = datetime.fromisoformat(str(created_at))
    age = datetime.now() - created_date
    return f"{age.days} Tage"

# Error Handler
def handle_transaction_error(error_type, message):
    """Zentrale Fehlerbehandlung für Transaktionen"""
    logging.error(f"Transaktionsfehler: {error_type} - {message}")
    return jsonify({
        "type": 4,
        "data": {
            "content": f"Ein Fehler ist aufgetreten: {message}",
            "error_type": error_type,
            "timestamp": datetime.now().isoformat()
        }
    })

class TransactionError(Exception):
    """Benutzerdefinierte Exception für Transaktionsfehler"""
    def __init__(self, message, error_type="TRANSACTION_ERROR"):
        self.message = message
        self.error_type = error_type
        super().__init__(self.message)

# Hilfreiche Utility-Funktionen
def validate_transaction(from_user_id, to_user_id, amount):
    """Überprüft, ob eine Transaktion gültig ist"""
    if from_user_id == to_user_id:
        raise TransactionError("Selbstüberweisung nicht möglich", "SELF_TRANSACTION_ERROR")
    
    if amount <= 0:
        raise TransactionError("Ungültiger Betrag", "INVALID_AMOUNT_ERROR")
    
    if not isinstance(amount, (int, float)):
        raise TransactionError("Betrag muss eine Zahl sein", "INVALID_TYPE_ERROR")
    
    return True

def format_currency(amount):
    """Formatiert einen Geldbetrag"""
    return f"{amount:,.2f} Credits"

def get_account_summary(user_id):
    """Erstellt eine Zusammenfassung des Kontos"""
    try:
        account = get_user_data(user_id)
        if not account:
            raise TransactionError("Konto nicht gefunden", "ACCOUNT_NOT_FOUND")
        
        return {
            "user_id": user_id,
            "balance": format_currency(account.get('credits', 0)),
            "last_transaction": account.get('last_transaction'),
            "account_status": "aktiv" if account.get('is_active', True) else "inaktiv",
            "created_at": account.get('created_at'),
            "last_daily_claim": account.get('last_claimed')
        }
    except Exception as e:
        logging.error(f"Fehler beim Erstellen der Kontozusammenfassung: {str(e)}")
        raise

# Initialisierung des Logging-Systems
def setup_logging():
    """Konfiguriert das Logging-System"""
    logging.basicConfig(
        level=logging.INFO,
        format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
        handlers=[
            logging.FileHandler('bank_transactions.log'),
            logging.StreamHandler()
        ]
    )

# Hauptfunktion zum Starten des Bank-Systems
def initialize_bank_system():
    """Initialisiert das Bank-System"""
    try:
        setup_logging()
        logging.info("Bank-System wird gestartet...")
        bank_system = BankSystem()
        logging.info("Bank-System erfolgreich initialisiert")
        return bank_system
    except Exception as e:
        logging.error(f"Fehler beim Initialisieren des Bank-Systems: {str(e)}")
        raise

if __name__ == "__main__":
    try:
        bank_system = initialize_bank_system()
        logging.info("Bank-System läuft und ist bereit")
    except Exception as e:
        logging.critical(f"Kritischer Fehler beim Starten des Bank-Systems: {str(e)}")