#!/bin/bash

# HTTPS-Setup-Skript für das MYP-Projekt
# Konfiguriert einen Raspberry Pi mit einer dual-network-Konfiguration
# - LAN (eth0): Firmennetzwerk mit Zugang zu Internet und unter https://m040tbaraspi001.de040.corpintra.net/ erreichbar
# - WLAN (wlan0): Verbindung zum Offline-Netzwerk, wo der Backend-Host erreichbar ist

# Farbcodes für Ausgabe
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color

# Funktion zur Ausgabe mit Zeitstempel
log() {
  echo -e "${BLUE}[$(date +'%Y-%m-%d %H:%M:%S')]${NC} $1"
}

error_log() {
  echo -e "${RED}[$(date +'%Y-%m-%d %H:%M:%S')] FEHLER:${NC} $1" >&2
}

success_log() {
  echo -e "${GREEN}[$(date +'%Y-%m-%d %H:%M:%S')] ERFOLG:${NC} $1"
}

header() {
  echo ""
  echo -e "${CYAN}===== $1 =====${NC}"
  echo ""
}

# Prüfen, ob das Skript als Root ausgeführt wird
if [ "$EUID" -ne 0 ]; then
  error_log "Dieses Skript muss als Root ausgeführt werden."
  error_log "Bitte führen Sie es mit 'sudo' aus."
  exit 1
fi

# Konfigurationswerte
FIRMENNETZWERK_HOSTNAME="m040tbaraspi001.de040.corpintra.net"
BACKEND_HOST="192.168.0.105"  # Backend-IP im Offline-Netzwerk
BACKEND_PORT="5000"           # Backend-Port
OFFLINE_NETWORK_SSID="MYP-Net"
OFFLINE_NETWORK_PASSWORD="myp-password"
CADDY_VERSION="2.7.6"

header "MYP-Netzwerk und HTTPS-Setup"
log "Dieses Skript konfiguriert Ihren Raspberry Pi für:"
log "1. Firmennetzwerk über LAN (eth0) mit Internet-Zugang"
log "2. Offline-Netzwerk über WLAN (wlan0) für Backend-Kommunikation"
log "3. HTTPS mit selbstsigniertem Zertifikat für ${FIRMENNETZWERK_HOSTNAME}"

# Netzwerkkonfiguration
setup_network() {
  header "Netzwerkkonfiguration"
  
  # Sichern der aktuellen Netzwerkkonfiguration
  log "Sichere aktuelle Netzwerkkonfiguration..."
  if [ -f /etc/dhcpcd.conf ]; then
    cp /etc/dhcpcd.conf /etc/dhcpcd.conf.bak
    success_log "Aktuelle Netzwerkkonfiguration gesichert in /etc/dhcpcd.conf.bak"
  fi
  
  # Konfigurieren von dhcpcd.conf für statische Routing
  log "Konfiguriere Routing für duale Netzwerke..."
  cat > /etc/dhcpcd.conf << EOL
# MYP Dual-Network Configuration
# eth0: Firmennetzwerk mit Internet
# wlan0: Offline-Netzwerk für Backend

# Allow dhcpcd to manage all interfaces
allowinterfaces eth0 wlan0

# eth0 configuration (Firmennetzwerk)
interface eth0
# DHCP for eth0, all default routes go through eth0
metric 100

# wlan0 configuration (Offline Network)
interface wlan0
# Static IP for wlan0
metric 200
# Add specific route to backend via wlan0
EOL
  
  # Konfigurieren von wpa_supplicant für WLAN-Verbindung
  log "Konfiguriere WLAN-Verbindung für Offline-Netzwerk..."
  cat > /etc/wpa_supplicant/wpa_supplicant.conf << EOL
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
country=DE

network={
    ssid="${OFFLINE_NETWORK_SSID}"
    psk="${OFFLINE_NETWORK_PASSWORD}"
    priority=1
}
EOL
  
  chmod 600 /etc/wpa_supplicant/wpa_supplicant.conf
  
  # Routing-Tabelle konfigurieren
  log "Konfiguriere spezifisches Routing zum Backend..."
  if ! grep -q "${BACKEND_HOST}" /etc/iproute2/rt_tables; then
    echo "200 backend" >> /etc/iproute2/rt_tables
  fi
  
  # Routing-Regeln in /etc/network/if-up.d/ hinzufügen
  cat > /etc/network/if-up.d/route-backend << EOL
#!/bin/bash
# Routing-Regeln für Backend-Host über WLAN

# Wenn wlan0 hochgefahren wird
if [ "\$IFACE" = "wlan0" ]; then
  # Spezifische Route zum Backend über wlan0
  /sbin/ip route add ${BACKEND_HOST}/32 dev wlan0
fi
EOL
  
  chmod +x /etc/network/if-up.d/route-backend
  
  success_log "Netzwerkkonfiguration abgeschlossen"
}

# Installation von Caddy als Reverse-Proxy
install_caddy() {
  header "Installation von Caddy als Reverse-Proxy"
  
  log "Überprüfe, ob Caddy bereits installiert ist..."
  if command -v caddy &> /dev/null; then
    success_log "Caddy ist bereits installiert"
  else
    log "Installiere Caddy ${CADDY_VERSION}..."
    
    # Download und Installation von Caddy
    wget -O /tmp/caddy.tar.gz "https://github.com/caddyserver/caddy/releases/download/v${CADDY_VERSION}/caddy_${CADDY_VERSION}_linux_armv7.tar.gz"
    
    if [ $? -ne 0 ]; then
      error_log "Fehler beim Herunterladen von Caddy"
      return 1
    fi
    
    tar -xzf /tmp/caddy.tar.gz -C /tmp
    mv /tmp/caddy /usr/local/bin/
    chmod +x /usr/local/bin/caddy
    
    # Benutzer und Gruppe für Caddy erstellen
    if ! id -u caddy &>/dev/null; then
      useradd --system --home /var/lib/caddy --shell /usr/sbin/nologin caddy
    fi
    
    # Verzeichnisse für Caddy erstellen
    mkdir -p /etc/caddy /var/lib/caddy /var/log/caddy
    chown -R caddy:caddy /var/lib/caddy /var/log/caddy
    
    # Systemd-Service für Caddy einrichten
    cat > /etc/systemd/system/caddy.service << EOL
[Unit]
Description=Caddy Web Server
Documentation=https://caddyserver.com/docs/
After=network.target network-online.target
Requires=network-online.target

[Service]
User=caddy
Group=caddy
ExecStart=/usr/local/bin/caddy run --config /etc/caddy/Caddyfile
ExecReload=/usr/local/bin/caddy reload --config /etc/caddy/Caddyfile
TimeoutStopSec=5s
LimitNOFILE=1048576
LimitNPROC=512
PrivateTmp=true
ProtectSystem=full
AmbientCapabilities=CAP_NET_BIND_SERVICE

[Install]
WantedBy=multi-user.target
EOL
    
    success_log "Caddy wurde installiert"
  fi
  
  # Caddyfile für HTTPS mit selbstsigniertem Zertifikat konfigurieren
  log "Konfiguriere Caddy für HTTPS mit selbstsigniertem Zertifikat..."
  cat > /etc/caddy/Caddyfile << EOL
{
    # Globale Optionen
    admin off
    auto_https disable_redirects
    
    # Selbstsigniertes Zertifikat verwenden
    local_certs
    default_sni ${FIRMENNETZWERK_HOSTNAME}
}

# HTTPS-Konfiguration für den Firmennetzwerk-Hostnamen
${FIRMENNETZWERK_HOSTNAME} {
    # TLS mit selbstsigniertem Zertifikat
    tls internal {
        on_demand
    }
    
    # Reverse-Proxy zum Next.js-Frontend
    reverse_proxy localhost:3000 {
        # Zeitüberschreitungen für langsame Raspberry Pi-Verbindungen erhöhen
        timeouts 5m
    }
    
    # Logging
    log {
        output file /var/log/caddy/access.log
        format console
    }
}

# HTTP-Konfiguration für lokalen Zugriff
:80 {
    # Weiterleitung zu HTTPS
    redir https://${FIRMENNETZWERK_HOSTNAME}{uri} permanent
}

# Zusätzlicher Server für Backend-Proxy (API-Anfragen weiterleiten)
localhost:8000 {
    reverse_proxy ${BACKEND_HOST}:${BACKEND_PORT} {
        # Headers für CORS anpassen
        header_up Host ${BACKEND_HOST}:${BACKEND_PORT}
        header_up X-Forwarded-Host ${FIRMENNETZWERK_HOSTNAME}
        header_up X-Forwarded-Proto https
        
        # Zeitüberschreitungen für API-Anfragen erhöhen
        timeouts 1m
    }
    
    # Logging
    log {
        output file /var/log/caddy/backend-access.log
        format console
    }
}
EOL
  
  # Caddy-Service neu laden und starten
  log "Starte Caddy-Service..."
  systemctl daemon-reload
  systemctl enable caddy
  systemctl restart caddy
  
  # Überprüfen, ob Caddy läuft
  if systemctl is-active --quiet caddy; then
    success_log "Caddy-Service wurde gestartet und ist aktiv"
  else
    error_log "Fehler beim Starten des Caddy-Services"
    return 1
  fi
  
  return 0
}

# Next.js Frontend-Konfiguration für HTTPS und Backend-Proxy
configure_frontend() {
  header "Frontend-Konfiguration für HTTPS"
  
  # Verzeichnis für das Frontend
  FRONTEND_DIR="/home/kasm-user/Desktop/Projektarbeit-MYP/packages/reservation-platform"
  
  # Prüfen, ob das Frontend-Verzeichnis existiert
  if [ ! -d "$FRONTEND_DIR" ]; then
    error_log "Frontend-Verzeichnis nicht gefunden: $FRONTEND_DIR"
    return 1
  fi
  
  log "Konfiguriere Frontend für HTTPS und Backend-Proxy..."
  
  # .env.local-Datei für das Frontend erstellen
  cat > "$FRONTEND_DIR/.env.local" << EOL
# Backend API Konfiguration (über lokalen Proxy zu Backend)
NEXT_PUBLIC_API_URL=http://localhost:8000

# Frontend-URL für OAuth Callback (HTTPS)
NEXT_PUBLIC_FRONTEND_URL=https://${FIRMENNETZWERK_HOSTNAME}

# Explizite OAuth Callback URL für GitHub
NEXT_PUBLIC_OAUTH_CALLBACK_URL=https://${FIRMENNETZWERK_HOSTNAME}/auth/login/callback
EOL
  
  # Berechtigungen setzen
  chown -R $(stat -c '%U:%G' "$FRONTEND_DIR") "$FRONTEND_DIR/.env.local"
  chmod 600 "$FRONTEND_DIR/.env.local"
  
  success_log "Frontend wurde für HTTPS und Backend-Proxy konfiguriert"
  
  # Hinweis zur Installation und zum Start des Frontends
  log "${YELLOW}Hinweis: Führen Sie nun das Frontend-Deployment-Skript aus:${NC}"
  log "cd /home/kasm-user/Desktop/Projektarbeit-MYP && ./raspi-frontend-deploy.sh"
  
  return 0
}

# Hostname setzen
set_hostname() {
  header "Hostname konfigurieren"
  
  log "Aktueller Hostname: $(hostname)"
  log "Setze Hostname auf ${FIRMENNETZWERK_HOSTNAME}..."
  
  # Hostname in /etc/hostname setzen
  echo "${FIRMENNETZWERK_HOSTNAME}" > /etc/hostname
  
  # Hostname in /etc/hosts aktualisieren
  if grep -q "$(hostname)" /etc/hosts; then
    sed -i "s/$(hostname)/${FIRMENNETZWERK_HOSTNAME}/g" /etc/hosts
  else
    echo "127.0.1.1       ${FIRMENNETZWERK_HOSTNAME}" >> /etc/hosts
  fi
  
  # Aktualisieren des Hostnamens ohne Neustart
  hostname "${FIRMENNETZWERK_HOSTNAME}"
  
  success_log "Hostname wurde auf ${FIRMENNETZWERK_HOSTNAME} gesetzt"
  log "${YELLOW}Hinweis: Ein Neustart wird empfohlen, um sicherzustellen, dass der neue Hostname vollständig übernommen wurde.${NC}"
  
  return 0
}

# Hauptfunktion
main() {
  # Begrüßung und Bestätigung
  header "MYP HTTPS und Dual-Network Setup"
  log "Dieses Skript richtet Ihren Raspberry Pi für das MYP-Projekt ein:"
  log "- Setzt den Hostname auf: ${FIRMENNETZWERK_HOSTNAME}"
  log "- Konfiguriert das duale Netzwerk (LAN für Internet, WLAN für Backend)"
  log "- Installiert Caddy als Reverse-Proxy mit selbstsigniertem HTTPS"
  log "- Konfiguriert das Frontend für die Kommunikation mit dem Backend"
  echo ""
  log "${YELLOW}WICHTIG: Diese Konfiguration kann bestehende Netzwerk- und HTTPS-Einstellungen überschreiben.${NC}"
  read -p "Möchten Sie fortfahren? (j/n): " confirm
  
  if [[ "$confirm" != "j" ]]; then
    log "Setup abgebrochen."
    exit 0
  fi
  
  # Schritte ausführen
  set_hostname || { error_log "Fehler beim Setzen des Hostnamens"; exit 1; }
  setup_network || { error_log "Fehler bei der Netzwerkkonfiguration"; exit 1; }
  install_caddy || { error_log "Fehler bei der Caddy-Installation"; exit 1; }
  configure_frontend || { error_log "Fehler bei der Frontend-Konfiguration"; exit 1; }
  
  # Abschlussmeldung
  header "Setup abgeschlossen"
  success_log "MYP HTTPS und Dual-Network Setup erfolgreich!"
  log "Ihr Raspberry Pi ist nun wie folgt konfiguriert:"
  log "- Hostname: ${FIRMENNETZWERK_HOSTNAME}"
  log "- HTTPS mit selbstsigniertem Zertifikat über Caddy"
  log "- Duale Netzwerkkonfiguration:"
  log "  * eth0: Firmennetzwerk mit Internet-Zugang"
  log "  * wlan0: Verbindung zum Offline-Netzwerk (${OFFLINE_NETWORK_SSID})"
  log "- Frontend-URL: https://${FIRMENNETZWERK_HOSTNAME}"
  log "- Backend-Kommunikation über lokalen Proxy: http://localhost:8000 -> ${BACKEND_HOST}:${BACKEND_PORT}"
  echo ""
  log "${YELLOW}Wichtige nächste Schritte:${NC}"
  log "1. Starten Sie das Frontend mit dem Deployment-Skript:"
  log "   cd /home/kasm-user/Desktop/Projektarbeit-MYP && ./raspi-frontend-deploy.sh"
  log "2. Neustart des Raspberry Pi empfohlen:"
  log "   sudo reboot"
  echo ""
  log "${YELLOW}Hinweis zum selbstsignierten Zertifikat:${NC}"
  log "Bei Zugriff auf https://${FIRMENNETZWERK_HOSTNAME} erhalten Sie eine Zertifikatswarnung im Browser."
  log "Dies ist normal für selbstsignierte Zertifikate. Sie können die Warnung in Ihrem Browser bestätigen."
}

# Skript starten
main