import os
import json
from datetime import timedelta

def get_env_variable(name: str, default: str = None) -> str:
    """
    Holt eine Umgebungsvariable oder gibt den Standardwert zurück.
    
    Args:
        name: Name der Umgebungsvariable
        default: Standardwert, falls die Variable nicht gesetzt ist
        
    Returns:
        str: Wert der Umgebungsvariable oder Standardwert
    """
    return os.environ.get(name, default)

# Hardcodierte Konfiguration
SECRET_KEY = "7445630171969DFAC92C53CEC92E67A9CB2E00B3CB2F"

# Dynamische Pfade basierend auf dem aktuellen Arbeitsverzeichnis
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  # backend/app
PROJECT_ROOT = os.path.dirname(BASE_DIR)  # Projektroot
DATABASE_PATH = os.path.join(PROJECT_ROOT, "database", "myp.db")  # ./database/myp.db

# ===== SMART PLUG KONFIGURATION =====
# TP-Link Tapo P110 Standardkonfiguration
TAPO_USERNAME = "till.tomczak@mercedes-benz.com"
TAPO_PASSWORD = "744563017196A"

# Automatische Steckdosen-Erkennung aktivieren
TAPO_AUTO_DISCOVERY = True

# Standard-Steckdosen-IPs (Mercedes-Benz TBA Marienfelde - 6 feste Arbeitsplätze)
DEFAULT_TAPO_IPS = [
    "192.168.0.100",  # 3D-Drucker 1 - TBA Marienfelde
    "192.168.0.101",  # 3D-Drucker 2 - TBA Marienfelde
    "192.168.0.102",  # 3D-Drucker 3 - TBA Marienfelde
    "192.168.0.103",  # 3D-Drucker 4 - TBA Marienfelde
    "192.168.0.104",  # 3D-Drucker 5 - TBA Marienfelde
    "192.168.0.106"   # 3D-Drucker 6 - TBA Marienfelde
]

# Timeout-Konfiguration für Tapo-Verbindungen
TAPO_TIMEOUT = 10  # Sekunden
TAPO_RETRY_COUNT = 3  # Anzahl Wiederholungsversuche

# Drucker-Konfiguration mit korrekten IPs
PRINTERS = {
    "3D-Drucker 1 - Halle A": {"ip": "192.168.1.101", "plug_ip": "192.168.1.201"},
    "3D-Drucker 2 - Halle A": {"ip": "192.168.1.102", "plug_ip": "192.168.1.202"},
    "3D-Drucker 3 - Halle B": {"ip": "192.168.1.103", "plug_ip": "192.168.1.203"},
    "3D-Drucker 4 - Halle B": {"ip": "192.168.1.104", "plug_ip": "192.168.1.204"},
    "3D-Drucker 5 - Labor": {"ip": "192.168.1.105", "plug_ip": "192.168.1.205"},
    "3D-Drucker 6 - Werkstatt": {"ip": "192.168.1.106", "plug_ip": "192.168.1.206"}
}

# Logging-Konfiguration
LOG_DIR = os.path.join(BASE_DIR, "logs")
LOG_SUBDIRS = ["app", "scheduler", "auth", "jobs", "printers", "errors"]
LOG_LEVEL = "INFO"
LOG_FORMAT = "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
LOG_DATE_FORMAT = "%Y-%m-%d %H:%M:%S"

# Flask-Konfiguration
FLASK_HOST = "0.0.0.0"
FLASK_PORT = 443  # Geändert von 443 auf 8443 (nicht-privilegierter Port)
FLASK_FALLBACK_PORT = 8080  # Geändert von 80 auf 8080 (nicht-privilegierter Port)
FLASK_DEBUG = True
SESSION_LIFETIME = timedelta(hours=2)  # Reduziert von 7 Tagen auf 2 Stunden für bessere Sicherheit

# Upload-Konfiguration
UPLOAD_FOLDER = os.path.join(PROJECT_ROOT, "uploads")  # ./uploads im Projektroot
ALLOWED_EXTENSIONS = {'txt', 'pdf', 'png', 'jpg', 'jpeg', 'gif', 'gcode', '3mf', 'stl'}
MAX_CONTENT_LENGTH = 16 * 1024 * 1024  # 16MB Maximum-Dateigröße
MAX_FILE_SIZE = 16 * 1024 * 1024  # 16MB Maximum-Dateigröße für Drag & Drop System

# Umgebungskonfiguration
ENVIRONMENT = get_env_variable("MYP_ENVIRONMENT", "development")

# SSL-Konfiguration
SSL_ENABLED = get_env_variable("MYP_SSL_ENABLED", "True").lower() in ("true", "1", "yes")
SSL_CERT_PATH = os.path.join(BASE_DIR, "certs", "myp.crt")
SSL_KEY_PATH = os.path.join(BASE_DIR, "certs", "myp.key")
SSL_HOSTNAME = get_env_variable("MYP_SSL_HOSTNAME", "localhost")

# Scheduler-Konfiguration
SCHEDULER_INTERVAL = 60  # Sekunden
SCHEDULER_ENABLED = True

# Datenbank-Konfiguration
DB_ENGINE = f"sqlite:///{DATABASE_PATH}"

# Mercedes-Benz TBA spezifische Konfiguration
FIXED_PRINTER_COUNT = 6  # Immer 6 feste Arbeitsplätze anzeigen
ALWAYS_SHOW_ALL_SOCKETS = True  # Alle 6 Steckdosen immer anzeigen, auch wenn offline

def get_log_file(category: str) -> str:
    """
    Gibt den Pfad zur Log-Datei für eine bestimmte Kategorie zurück.
    
    Args:
        category: Log-Kategorie (app, scheduler, auth, jobs, printers, errors)
        
    Returns:
        str: Pfad zur Log-Datei
    """
    if category not in LOG_SUBDIRS:
        category = "app"
    
    return os.path.join(LOG_DIR, category, f"{category}.log")

def ensure_log_directories():
    """Erstellt alle erforderlichen Log-Verzeichnisse."""
    os.makedirs(LOG_DIR, exist_ok=True)
    for subdir in LOG_SUBDIRS:
        os.makedirs(os.path.join(LOG_DIR, subdir), exist_ok=True)

def ensure_database_directory():
    """Erstellt das Datenbank-Verzeichnis."""
    db_dir = os.path.dirname(DATABASE_PATH)
    if db_dir:
        os.makedirs(db_dir, exist_ok=True)

def ensure_ssl_directory():
    """Erstellt das SSL-Verzeichnis, falls es nicht existiert."""
    ssl_dir = os.path.dirname(SSL_CERT_PATH)
    if ssl_dir and not os.path.exists(ssl_dir):
        os.makedirs(ssl_dir, exist_ok=True)

def ensure_upload_directory():
    """Erstellt das Upload-Verzeichnis, falls es nicht existiert."""
    if not os.path.exists(UPLOAD_FOLDER):
        os.makedirs(UPLOAD_FOLDER, exist_ok=True)

def get_ssl_context():
    """
    Gibt den SSL-Kontext für Flask zurück, wenn SSL aktiviert ist.
    
    Returns:
        tuple oder None: Tuple mit Zertifikat- und Schlüsselpfad, wenn SSL aktiviert ist, sonst None
    """
    if not SSL_ENABLED:
        return None
    
    # Wenn Zertifikate nicht existieren, diese automatisch erstellen
    if not os.path.exists(SSL_CERT_PATH) or not os.path.exists(SSL_KEY_PATH):
        ensure_ssl_directory()
        
        # Im Entwicklungsmodus versuchen wir, einfache Zertifikate zu erstellen
        if FLASK_DEBUG:
            print("SSL-Zertifikate nicht gefunden. Erstelle einfache selbstsignierte Zertifikate...")
            try:
                # Einfache Zertifikate mit Python erstellen
                create_simple_ssl_cert()
                
                # Prüfen, ob die Zertifikate erfolgreich erstellt wurden
                if not os.path.exists(SSL_CERT_PATH) or not os.path.exists(SSL_KEY_PATH):
                    print("Konnte keine SSL-Zertifikate erstellen.")
                    return None
                    
            except Exception as e:
                print(f"Fehler beim Erstellen der SSL-Zertifikate: {e}")
                return None
        else:
            print("WARNUNG: SSL-Zertifikate nicht gefunden und Nicht-Debug-Modus. SSL wird deaktiviert.")
            return None
    
    return (SSL_CERT_PATH, SSL_KEY_PATH)

def create_simple_ssl_cert():
    """
    Erstellt ein Mercedes-Benz SSL-Zertifikat mit dem neuen SSL-Manager.
    """
    try:
        # Verwende den neuen SSL-Manager
        from utils.ssl_manager import ssl_manager
        success = ssl_manager.generate_mercedes_certificate()
        
        if success:
            print(f"Mercedes-Benz SSL-Zertifikat erfolgreich erstellt: {SSL_CERT_PATH}")
            return True
        else:
            print("Fehler beim Erstellen des Mercedes-Benz SSL-Zertifikats")
            return None
            
    except ImportError as e:
        print(f"SSL-Manager nicht verfügbar: {e}")
        return None
    except Exception as e:
        print(f"Fehler beim Erstellen der SSL-Zertifikate: {e}")
        return None